@bman654/clodex 2.1.9 → 2.2.1

package/dist/cli.js

@@ -9,6 +9,7 @@ import {
   getCredentialMutationLockPath,
   getCredentialStateRoot,
   getInstalledClaudeVersion,
+  getLocalPatchesPath,
   getLogsPath,
   getSavedServerPassword,
   getServerExposedProviders,
@@ -39,7 +40,7 @@ import {
   withProviderMutationLock,
   withRegistryWriteLock,
   withRegistryWriteLockSync
-} from "./chunk-VQOX3AXE.js";
+} from "./chunk-W4SVDQCZ.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -217,7 +218,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.1.9",
+  version: "2.2.1",
   publishConfig: {
     access: "public"
   },
@@ -273,7 +274,7 @@ var package_default = {
     open: "11.0.0",
     picocolors: "1.1.1",
     tweakcc: "4.3.0",
-    undici: "7.28.0",
+    undici: "7.29.0",
     ws: "8.21.0"
   },
   devDependencies: {
@@ -13917,16 +13918,16 @@ function planLaunchWizard(opts) {
 }
 
 // src/patcher.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
   copyFileSync,
   existsSync as existsSync7,
   mkdtempSync,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   renameSync as renameSync3,
   rmSync,
-  statSync as statSync4,
+  statSync as statSync5,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync7,
   openSync as openSync4,
@@ -13938,9 +13939,380 @@ import { basename, dirname as dirname5, join as join8 } from "path";
 import pc12 from "picocolors";
 import * as p11 from "@clack/prompts";
 
-// src/patch-backup.ts
+// src/local-patches.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync8, readdirSync, statSync as statSync3 } from "fs";
+import { readFileSync as readFileSync8, statSync as statSync3 } from "fs";
+var LOCAL_PATCH_API_VERSION = 1;
+var LOCAL_PATCH_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+var MAX_LOCAL_PATCH_BYTES = 1024 * 1024;
+var RESERVED_MARKER_PREFIX = "/*ccpatch:";
+var LOCAL_MARKER_PREFIX = "/*clodex-local:";
+var MAX_ERROR_LENGTH = 300;
+var localModuleEvaluationSequence = 0;
+function describeLocalError(error) {
+  const raw = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  const redacted = raw.replace(
+    /data:text\/javascript;base64,[^\s"'`]+/g,
+    "<local-patches.mjs>"
+  );
+  const singleLine = redacted.replace(/[\r\n\t]+/g, " ").replace(/\s{2,}/g, " ").trim();
+  if (singleLine.length <= MAX_ERROR_LENGTH) return singleLine || "unknown error";
+  return `${singleLine.slice(0, MAX_ERROR_LENGTH - 1)}\u2026`;
+}
+function describeLocalId(id) {
+  const encoded = JSON.stringify(id);
+  return encoded.length <= 96 ? encoded : `${encoded.slice(0, 95)}\u2026`;
+}
+function countOccurrences(source, needle) {
+  let count = 0;
+  let offset = 0;
+  while ((offset = source.indexOf(needle, offset)) !== -1) {
+    count += 1;
+    offset += needle.length;
+  }
+  return count;
+}
+function reservedMarkerInventory(source) {
+  const count = countOccurrences(source, RESERVED_MARKER_PREFIX);
+  const markers = source.match(/\/\*ccpatch:[\s\S]*?\*\//g)?.sort() ?? [];
+  return JSON.stringify([count, markers]);
+}
+function localMarkerInventory(source) {
+  const count = countOccurrences(source, LOCAL_MARKER_PREFIX);
+  const markers = source.match(/\/\*clodex-local:[\s\S]*?\*\//g)?.sort() ?? [];
+  return JSON.stringify([count, markers]);
+}
+function inspectLocalPatchSource(enabled) {
+  const path = getLocalPatchesPath();
+  if (!enabled) return { enabled: false, path };
+  try {
+    const stats = statSync3(path);
+    if (!stats.isFile()) throw Object.assign(new Error("not a regular file"), { code: "EINVAL" });
+    if (stats.size > MAX_LOCAL_PATCH_BYTES) {
+      throw Object.assign(new Error("module exceeds 1 MiB"), { code: "EFBIG" });
+    }
+    const bytes = readFileSync8(path);
+    if (bytes.length > MAX_LOCAL_PATCH_BYTES) {
+      throw Object.assign(new Error("module exceeds 1 MiB"), { code: "EFBIG" });
+    }
+    const digest = createHash7("sha256").update(bytes).digest("hex");
+    const source = bytes.toString("utf8");
+    if (!Buffer.from(source, "utf8").equals(bytes)) {
+      return {
+        enabled: true,
+        path,
+        configIdentity: `v${LOCAL_PATCH_API_VERSION}:invalid-utf8:${digest}`,
+        error: `could not read ${path}: module must be UTF-8`
+      };
+    }
+    return {
+      enabled: true,
+      path,
+      configIdentity: `v${LOCAL_PATCH_API_VERSION}:${digest}`,
+      source
+    };
+  } catch (error) {
+    const code = error instanceof Error && "code" in error ? String(error.code) : "UNKNOWN";
+    const reason = code === "EFBIG" ? "module exceeds 1 MiB" : code === "EINVAL" ? "not a regular file" : code;
+    return {
+      enabled: true,
+      path,
+      configIdentity: `v${LOCAL_PATCH_API_VERSION}:unavailable:${code}`,
+      error: `could not read ${path}: ${reason}`
+    };
+  }
+}
+function failedLocalTransaction(source, patches, results, failedIndex, extra) {
+  const failedName = `LOCAL ${patches[failedIndex].id}`;
+  const rolledBack = results.map((result) => result.status === "OK" ? {
+    status: "SKIP",
+    name: result.name,
+    extra: `rolled back after ${failedName} failed`
+  } : result);
+  rolledBack.push({ status: "FAIL", name: failedName, extra });
+  for (const remaining of patches.slice(failedIndex + 1)) {
+    rolledBack.push({
+      status: "SKIP",
+      name: `LOCAL ${remaining.id}`,
+      extra: `not run after ${failedName} failed`
+    });
+  }
+  return { content: source, results: rolledBack };
+}
+function snapshotLocalPatchDefinitions(value) {
+  if (!Array.isArray(value)) return "default export must be an array";
+  const rawDefinitions = [...value];
+  const snapshot = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, definition] of rawDefinitions.entries()) {
+    if (definition === null || typeof definition !== "object") {
+      return `entry at index ${index} must be an object`;
+    }
+    const candidate = definition;
+    const id = candidate.id;
+    const apply = candidate.apply;
+    if (typeof id !== "string") return `entry at index ${index} must have a string id`;
+    if (typeof apply !== "function") {
+      return `entry ${describeLocalId(id)} must have an apply function`;
+    }
+    if (!LOCAL_PATCH_ID_PATTERN.test(id)) {
+      return `invalid id at index ${index}: ${describeLocalId(id)}`;
+    }
+    if (ids.has(id)) return `duplicate id at index ${index}: ${describeLocalId(id)}`;
+    ids.add(id);
+    snapshot.push(Object.freeze({ id, apply }));
+  }
+  return Object.freeze(snapshot);
+}
+function applyLocalPatchSnapshot(source, patches) {
+  let content = source;
+  const results = [];
+  for (const [index, patch] of patches.entries()) {
+    const marker = `/*clodex-local:${patch.id}*/`;
+    const existingMarkerCount = countOccurrences(content, marker);
+    if (existingMarkerCount > 1) {
+      return failedLocalTransaction(
+        source,
+        patches,
+        results,
+        index,
+        "existing marker appears more than once"
+      );
+    }
+    if (existingMarkerCount === 1) {
+      results.push({
+        status: "SKIP",
+        name: `LOCAL ${patch.id}`,
+        extra: "already patched"
+      });
+      continue;
+    }
+    let next;
+    const reservedMarkers = reservedMarkerInventory(content);
+    const localMarkers = localMarkerInventory(content);
+    try {
+      next = patch.apply(content, { marker });
+    } catch (error) {
+      return failedLocalTransaction(
+        source,
+        patches,
+        results,
+        index,
+        describeLocalError(error)
+      );
+    }
+    if (typeof next !== "string") {
+      return failedLocalTransaction(
+        source,
+        patches,
+        results,
+        index,
+        `transform returned ${typeof next} instead of a string`
+      );
+    }
+    if (reservedMarkerInventory(next) !== reservedMarkers) {
+      return failedLocalTransaction(
+        source,
+        patches,
+        results,
+        index,
+        "transform changed reserved /*ccpatch: markers"
+      );
+    }
+    const markerCount = countOccurrences(next, marker);
+    if (markerCount !== 1) {
+      return failedLocalTransaction(
+        source,
+        patches,
+        results,
+        index,
+        markerCount === 0 ? `transform did not emit ${marker}` : `transform must emit exactly one ${marker} marker`
+      );
+    }
+    if (localMarkerInventory(next.replace(marker, "")) !== localMarkers) {
+      return failedLocalTransaction(
+        source,
+        patches,
+        results,
+        index,
+        "transform changed another local patch marker"
+      );
+    }
+    content = next;
+    results.push({ status: "OK", name: `LOCAL ${patch.id}` });
+  }
+  return { content, results };
+}
+function localPatchSetFailure(source, extra) {
+  return {
+    content: source,
+    results: [{ status: "FAIL", name: "LOCAL PATCH SET", extra }]
+  };
+}
+async function applyLocalPatches(source, localSource) {
+  if (!localSource.enabled) return { content: source, results: [] };
+  if (typeof localSource.error === "string") {
+    return localPatchSetFailure(source, localSource.error);
+  }
+  try {
+    const moduleUrl = `data:text/javascript;base64,${Buffer.from(localSource.source).toString("base64")}#clodex-local-eval-${++localModuleEvaluationSequence}`;
+    const loaded = await import(
+      /* @vite-ignore */
+      moduleUrl
+    );
+    const definitions = snapshotLocalPatchDefinitions(loaded.default);
+    if (typeof definitions === "string") {
+      return localPatchSetFailure(source, definitions);
+    }
+    if (definitions.length === 0) {
+      return {
+        content: source,
+        results: [{
+          status: "SKIP",
+          name: "LOCAL PATCH SET",
+          extra: "no patches exported"
+        }]
+      };
+    }
+    return applyLocalPatchSnapshot(source, definitions);
+  } catch (error) {
+    return localPatchSetFailure(
+      source,
+      describeLocalError(error)
+    );
+  }
+}
+
+// src/built-in-patch-proofs.ts
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function countExactOccurrences(source, needle) {
+  let count = 0;
+  let offset = 0;
+  while ((offset = source.indexOf(needle, offset)) !== -1) {
+    count += 1;
+    offset += needle.length;
+  }
+  return count;
+}
+function uniqueMatch(source, name, pattern) {
+  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+  const matcher = new RegExp(pattern.source, flags);
+  const match = matcher.exec(source);
+  if (!match || matcher.exec(source)) {
+    throw new Error(`clodex patch: could not capture built-in postcondition: ${name}`);
+  }
+  return match[0];
+}
+function captureNeedle(source, name, needle) {
+  if (countExactOccurrences(source, needle) !== 1) {
+    throw new Error(`clodex patch: could not capture built-in postcondition: ${name}`);
+  }
+  return {
+    name,
+    protectedText: needle,
+    occurrences: 1
+  };
+}
+function capturePattern(source, name, pattern) {
+  return captureNeedle(source, name, uniqueMatch(source, name, pattern));
+}
+function normalizedPatchName(name) {
+  return name.replace(/ \(refresh\)$/, "");
+}
+function protectsResult(results, name) {
+  const result = results.find((entry) => normalizedPatchName(entry.name) === name);
+  return result !== void 0 && result.status !== "FAIL" && result.extra !== "no aliases configured";
+}
+function configuredAliases(config) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(config)) {
+    if (entry.alias === void 0) continue;
+    const alias = String(entry.alias).trim().toLowerCase();
+    aliases.set(alias, {
+      id,
+      ...entry.display === void 0 ? {} : { display: String(entry.display) }
+    });
+  }
+  return [...aliases].map(([alias, entry]) => ({ alias, ...entry }));
+}
+function effortProofPattern(marker) {
+  return new RegExp(
+    escapeRegex(marker) + 'var _ccv=Object\\.assign\\(Object\\.create\\(null\\),\\{[^{}]*\\}\\)\\[String\\([\\w$]+\\|\\|""\\)\\.trim\\(\\)\\.toLowerCase\\(\\)\\];if\\(_ccv!==void 0\\)return _ccv;'
+  );
+}
+function captureBuiltInPatchProofs(source, config, results) {
+  const proofs = [];
+  const addPattern = (name, pattern) => {
+    if (protectsResult(results, name)) {
+      proofs.push(capturePattern(source, name, pattern));
+    }
+  };
+  addPattern(
+    "PATCH 1: Agent tool model enum",
+    /(?:\.enum|model:[A-Za-z_$][\w$]*)\(\["sonnet","opus","haiku"(?:,"[^"]+")*\]\)\.optional\(\)\.describe\(/
+  );
+  addPattern(
+    "PATCH 3: known-alias validator list",
+    /\["sonnet","opus","haiku","fable"(?:,"[^"]+")*,"opusplan"(?:,"[^"]+")*\]/
+  );
+  addPattern(
+    "PATCH 4: Agent tool model description",
+    /describe\(`Optional model override for this agent[^`]*?`\)/
+  );
+  const aliases = configuredAliases(config);
+  if (protectsResult(results, "PATCH 6: alias resolver switch")) {
+    for (const { alias } of aliases) {
+      const value = JSON.stringify(alias);
+      proofs.push(captureNeedle(
+        source,
+        `PATCH 6: alias resolver switch (${alias})`,
+        `case${value}:return ${value};`
+      ));
+    }
+  }
+  if (protectsResult(results, "PATCH 5: model picker options")) {
+    for (const { alias, id, display } of aliases) {
+      const entry = "{value:" + JSON.stringify(alias) + ",label:" + JSON.stringify(alias.charAt(0).toUpperCase() + alias.slice(1)) + ",description:" + JSON.stringify(display ?? `Custom model (${id})`) + "}";
+      proofs.push(captureNeedle(
+        source,
+        `PATCH 5: model picker options (${alias})`,
+        entry
+      ));
+    }
+  }
+  addPattern(
+    "PATCH 7: per-model context window",
+    /\/\*ccpatch:ctx\*\/var _ccw=\(\{[^{}]*\}\)\[[^\]]*\];if\(_ccw!==void 0\)return _ccw;/
+  );
+  addPattern(
+    "PATCH 8a: effort capability",
+    effortProofPattern("/*ccpatch:effort*/")
+  );
+  addPattern(
+    "PATCH 8b: xhigh effort capability",
+    effortProofPattern("/*ccpatch:xhigh-effort*/")
+  );
+  addPattern(
+    "PATCH 8c: max effort capability",
+    effortProofPattern("/*ccpatch:max-effort*/")
+  );
+  addPattern(
+    "PATCH 9: default effort",
+    /\/\*ccpatch:default-effort\*\/var _cce=Object\.assign\(Object\.create\(null\),\{[^{}]*\}\)\[String\([\w$]+\|\|""\)\.trim\(\)\.toLowerCase\(\)\];if\(_cce!==void 0\)return _cce;/
+  );
+  return proofs;
+}
+function builtInPatchProofsChanged(source, proofs) {
+  return proofs.some(
+    (proof) => countExactOccurrences(source, proof.protectedText) !== proof.occurrences
+  );
+}
+
+// src/patch-backup.ts
+import { createHash as createHash8 } from "crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync9, readdirSync, statSync as statSync4 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join7 } from "path";
 var BACKUP_SHA_PREFIX_LENGTH = 16;
@@ -13948,7 +14320,7 @@ function backupDir() {
   return process.env["TWEAKCC_CONFIG_DIR"]?.trim() || join7(homedir2(), ".tweakcc");
 }
 function sha256File(path) {
-  return createHash7("sha256").update(readFileSync8(path)).digest("hex");
+  return createHash8("sha256").update(readFileSync9(path)).digest("hex");
 }
 function backupVersionTag(version) {
   const tag = version.trim().replace(/[^\w.-]+/g, "_");
@@ -13978,7 +14350,7 @@ function scanPristineBackups(version, dir = backupDir()) {
     const path = join7(dir, entry);
     let sha256;
     try {
-      if (!statSync3(path).isFile()) continue;
+      if (!statSync4(path).isFile()) continue;
       sha256 = sha256File(path);
     } catch {
       corrupt.push(path);
@@ -14092,7 +14464,7 @@ function collectPristineFacts(args) {
 }
 
 // src/patch-transforms.ts
-var PATCH_TRANSFORMS_VERSION = 2;
+var PATCH_TRANSFORMS_VERSION = 3;
 var NATIVE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 var BASE_EFFORT_LEVELS = ["low", "medium", "high"];
 function projectNativeEffort(effort) {
@@ -14238,8 +14610,8 @@ function applyClodexPatches(source, config) {
   }
   applyOnce(
     "PATCH 1: Agent tool model enum",
-    /\.enum\((\["sonnet","opus","haiku"(?:,"[^"]+")*\])\)\.optional\(\)\.describe\(/,
-    (_m, arr) => ".enum(" + extendAliasArray(arr) + ").optional().describe(",
+    /((?:\.enum|model:[A-Za-z_$][\w$]*)\()(\["sonnet","opus","haiku"(?:,"[^"]+")*\])\)(\.optional\(\)\.describe\()/,
+    (_m, open2, arr, tail) => open2 + extendAliasArray(arr) + ")" + tail,
     { required: true, noopIsSkip: true }
   );
   applyOnce(
@@ -14399,7 +14771,7 @@ function getPatchLockPath() {
 }
 function readPatchManifest(path = getPatchManifestPath()) {
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    const parsed = JSON.parse(readFileSync10(path, "utf8"));
     if (parsed && typeof parsed.binaryPath === "string" && typeof parsed.configHash === "string") {
       return parsed;
     }
@@ -14465,7 +14837,7 @@ function reportRejectedModelAliases(rejections) {
     );
   }
 }
-function computePatchConfigHash(config, transformsVersion = PATCH_TRANSFORMS_VERSION) {
+function computePatchConfigHash(config, transformsVersion = PATCH_TRANSFORMS_VERSION, localPatchIdentity) {
   const canonical = Object.keys(config).sort().map((key) => {
     const entry = config[key];
     return [
@@ -14477,7 +14849,11 @@ function computePatchConfigHash(config, transformsVersion = PATCH_TRANSFORMS_VER
       entry.effort?.defaultLevel ?? null
     ];
   });
-  return createHash8("sha256").update(JSON.stringify([transformsVersion, canonical])).digest("hex");
+  const payload = [transformsVersion, canonical];
+  if (localPatchIdentity !== void 0) {
+    payload.push(["local-patches", localPatchIdentity]);
+  }
+  return createHash9("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 function buildDesiredPatchConfig() {
   const prefs = loadPreferences();
@@ -14548,7 +14924,7 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
     } catch {
       let stale = false;
       try {
-        const existing = JSON.parse(readFileSync9(lockPath, "utf8"));
+        const existing = JSON.parse(readFileSync10(lockPath, "utf8"));
         stale = !existing.pid || !isAlive(existing.pid) || typeof existing.startedAt === "number" && now - existing.startedAt > PATCH_LOCK_STALE_MS;
       } catch {
         stale = true;
@@ -14574,7 +14950,7 @@ function resolveClaudeBinaryForPatch() {
     return { ok: false, reason: "binary-not-found" };
   }
   try {
-    if (!statSync4(resolved).isFile()) return { ok: false, reason: "binary-not-found" };
+    if (!statSync5(resolved).isFile()) return { ok: false, reason: "binary-not-found" };
   } catch {
     return { ok: false, reason: "binary-not-found" };
   }
@@ -14626,6 +15002,49 @@ function requiredEffortPatchFailures(results) {
     (result) => result.status === "FAIL" && (result.name.startsWith("PATCH 8a:") || result.name.startsWith("PATCH 8b:") || result.name.startsWith("PATCH 8c:") || result.name.startsWith("PATCH 9:"))
   );
 }
+function builtInPatchVerificationFailed(source, config, expected, proofs) {
+  if (builtInPatchProofsChanged(source, proofs)) return true;
+  let verification;
+  try {
+    verification = applyClodexPatches(source, config);
+  } catch {
+    return true;
+  }
+  if (verification.content !== source || verification.results.length !== expected.length) {
+    return true;
+  }
+  const expectedByName = new Map(expected.map((result) => [
+    result.name.replace(/ \(refresh\)$/, ""),
+    result
+  ]));
+  for (const result of verification.results) {
+    const original = expectedByName.get(result.name.replace(/ \(refresh\)$/, ""));
+    if (!original) return true;
+    if (original.status === "FAIL") {
+      if (result.status !== "FAIL" || result.extra !== original.extra) return true;
+    } else if (result.status !== "SKIP") {
+      return true;
+    }
+  }
+  return false;
+}
+function discardLocalPatchOutcome(builtInContent, results) {
+  return {
+    content: builtInContent,
+    results: [
+      ...results.map((result) => result.status === "OK" ? {
+        status: "SKIP",
+        name: result.name,
+        extra: "rolled back after built-in verification failed"
+      } : result),
+      {
+        status: "FAIL",
+        name: "LOCAL PATCH SET",
+        extra: "local output changed built-in patch sites"
+      }
+    ]
+  };
+}
 async function applyPatch(binaryPath, version, desired, configHash, opts) {
   let candidateDir;
   let results;
@@ -14689,8 +15108,8 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
       backup = canonical;
     }
     publishBackupFile(backup, tweakccMirrorBackupPath());
-    const patched = applyClodexPatches(loaded.source, desired.config);
-    results = patched.results;
+    const builtIn = applyClodexPatches(loaded.source, desired.config);
+    results = builtIn.results;
     const failedEffortPatches = requiredEffortPatchFailures(results);
     if (failedEffortPatches.length > 0) {
       throw new PatchApplyError(
@@ -14698,8 +15117,38 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
         results
       );
     }
-    await writeContent(loaded.installation, patched.content);
-    patchedSize = statSync4(candidatePath).size;
+    let builtInProofs = [];
+    let local;
+    if (opts.localPatches?.enabled && typeof opts.localPatches.source === "string") {
+      try {
+        builtInProofs = captureBuiltInPatchProofs(
+          builtIn.content,
+          desired.config,
+          builtIn.results
+        );
+      } catch {
+        local = {
+          content: builtIn.content,
+          results: [{
+            status: "FAIL",
+            name: "LOCAL PATCH SET",
+            extra: "could not capture built-in postconditions"
+          }]
+        };
+      }
+    }
+    local ??= opts.localPatches ? await applyLocalPatches(builtIn.content, opts.localPatches) : { content: builtIn.content, results: [] };
+    if (local.results.some((result) => result.status === "OK") && builtInPatchVerificationFailed(
+      local.content,
+      desired.config,
+      builtIn.results,
+      builtInProofs
+    )) {
+      local = discardLocalPatchOutcome(builtIn.content, local.results);
+    }
+    results = [...results, ...local.results];
+    await writeContent(loaded.installation, local.content);
+    patchedSize = statSync5(candidatePath).size;
     patchedSha256 = sha256File(candidatePath);
     renameSync3(candidatePath, binaryPath);
   } catch (err) {
@@ -14799,6 +15248,9 @@ async function runPatchCommand(opts = {}) {
     return 1;
   }
   const { binaryPath, version } = target;
+  if (opts.localPatches !== void 0) {
+    savePreferences({ localPatchesEnabled: opts.localPatches });
+  }
   const desired = buildDesiredPatchConfig();
   if (Object.keys(desired.config).length === 0) {
     p11.log.error("No favorite models to patch. Save favorites with `clodex models` first.");
@@ -14808,13 +15260,20 @@ async function runPatchCommand(opts = {}) {
     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 localPatches = inspectLocalPatchSource(
+    loadPreferences().localPatchesEnabled === true
+  );
+  const configHash = computePatchConfigHash(
+    desired.config,
+    PATCH_TRANSFORMS_VERSION,
+    localPatches.enabled ? localPatches.configIdentity : void 0
+  );
   const manifest = readPatchManifest();
   const state = evaluatePatchState(manifest, {
     binaryPath,
     claudeVersion: version,
     configHash,
-    binarySize: statSync4(binaryPath).size
+    binarySize: statSync5(binaryPath).size
   });
   if (state === "current") {
     p11.log.success(`claude ${version} is already patched with the current model config \u2014 nothing to do.`);
@@ -14828,7 +15287,8 @@ async function runPatchCommand(opts = {}) {
   try {
     const outcome = await applyPatch(binaryPath, version, desired, configHash, {
       trace: opts.trace ?? false,
-      manifest
+      manifest,
+      localPatches
     });
     if (!outcome.ok) {
       p11.log.error(outcome.message);
@@ -14856,13 +15316,20 @@ async function runLaunchPatchCheck(opts = {}) {
       return;
     }
     const resolved = target;
-    const configHash = computePatchConfigHash(desired.config);
+    const localPatches = inspectLocalPatchSource(
+      loadPreferences().localPatchesEnabled === true
+    );
+    const configHash = computePatchConfigHash(
+      desired.config,
+      PATCH_TRANSFORMS_VERSION,
+      localPatches.enabled ? localPatches.configIdentity : void 0
+    );
     const manifest = readPatchManifest();
     const state = evaluatePatchState(manifest, {
       binaryPath: resolved.binaryPath,
       claudeVersion: resolved.version,
       configHash,
-      binarySize: statSync4(resolved.binaryPath).size
+      binarySize: statSync5(resolved.binaryPath).size
     });
     if (state === "current") return;
     const interactive = !opts.dryRun && !opts.agentStdout && process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -15068,9 +15535,22 @@ function parseArgs(args) {
       if (arg === "--help" || arg === "-h") parsed2.showHelp = true;
       else if (arg === "--version" || arg === "-v") parsed2.showVersion = true;
       else if (arg === "--restore") parsed2.patchRestore = true;
-      else if (arg === "--trace") parsed2.trace = true;
+      else if (arg === "--enable-local-patches") {
+        if (parsed2.patchLocalPatches === false && !parsed2.error) {
+          parsed2.error = "--enable-local-patches and --disable-local-patches cannot be combined";
+        }
+        parsed2.patchLocalPatches = true;
+      } else if (arg === "--disable-local-patches") {
+        if (parsed2.patchLocalPatches === true && !parsed2.error) {
+          parsed2.error = "--enable-local-patches and --disable-local-patches cannot be combined";
+        }
+        parsed2.patchLocalPatches = false;
+      } else if (arg === "--trace") parsed2.trace = true;
       else if (!parsed2.error) parsed2.error = `Unknown patch option: ${arg}`;
     }
+    if (parsed2.patchRestore && parsed2.patchLocalPatches !== void 0 && !parsed2.error) {
+      parsed2.error = "--restore cannot be combined with local-patch settings";
+    }
     return parsed2;
   }
   if (first !== "claude") {
@@ -15113,7 +15593,7 @@ Bridge Claude Code to OpenAI models \u2014 OpenAI API key or ChatGPT/Codex-plan
 ${pc13.bold("Usage:")}
   clodex claude [options] [claude-flags]
   clodex server [options]
-  clodex patch [--restore]
+  clodex patch [options]
   clodex models
   clodex favorites
   clodex providers
@@ -15325,11 +15805,15 @@ real ids, and reporting the correct context window.
 ${pc13.bold("Usage:")}
   clodex patch
   clodex patch --restore
+  clodex patch --enable-local-patches
+  clodex patch --disable-local-patches
   clodex patch --help
 
 ${pc13.bold("Options:")}
-  --restore    Restore the pristine (unpatched) Claude Code binary
-  --trace      Show per-patch-site results (OK/SKIP/FAIL)
+  --restore                  Restore the pristine Claude Code binary
+  --trace                    Show per-patch-site results (OK/SKIP/FAIL)
+  --enable-local-patches     Persistently enable ~/.clodex/local-patches.mjs
+  --disable-local-patches    Disable local patches and rebuild without them
 
 ${pc13.bold("Behavior:")}
   The patch map is built automatically from your clodex favorites and aliases
@@ -15337,6 +15821,10 @@ ${pc13.bold("Behavior:")}
   per-version backup is kept, and a manifest (~/.clodex/patch-state.json)
   makes re-runs no-ops until your config or Claude Code version changes \u2014
   then the binary is restored first and re-patched fresh.
+
+  Local patches execute after the built-ins as an all-or-none set. Enabling
+  them executes trusted JavaScript from local-patches.mjs with your full user
+  permissions. Local failures are reported but never block the built-ins.
   Run clodex patch again after every claude update.`;
 }
 function printHelp(text4) {
@@ -16143,7 +16631,11 @@ Error: ${parsed.error}
       printHelp(patchHelpText());
       return 0;
     }
-    return runPatchCommand({ restore: parsed.patchRestore, trace: parsed.trace });
+    return runPatchCommand({
+      restore: parsed.patchRestore,
+      trace: parsed.trace,
+      localPatches: parsed.patchLocalPatches
+    });
   }
   if (parsed.showVersion) {
     console.log(VERSION);