@bman654/clodex 2.12.0 → 2.12.1

package/README.md

@@ -198,9 +198,9 @@ Patch the installed Claude Code binary so clodex favorites and aliases are first
 | `--disable-local-patches` | Disable local patches and rebuild from pristine bytes without them |
 | `--help` | Help |
 
-On Windows, when Claude Code was installed with `npm install -g`, the `claude` on your PATH is a small launcher script (`claude.cmd`, `claude.ps1`, and an extensionless one) rather than the program itself; `clodex patch` follows it to the program and patches that. (On macOS and Linux npm makes a symlink instead, which always worked.) If the launcher cannot be followed — its program moved or removed, or it names two different programs — `clodex patch` stops without touching anything and tells you to set `CLODEX_CLAUDE_PATH` to the program directly.
+On Windows, when Claude Code was installed with `npm install -g`, the `claude` on your PATH is a small launcher script (`claude.cmd`, `claude.ps1`, and an extensionless one) rather than the program itself; `clodex patch` follows it to the program and patches that. (On macOS and Linux npm makes a symlink instead, which always worked.) If the launcher cannot be followed — its program moved or removed, or it names two different programs — `clodex patch` stops without touching anything and tells you to set `TWEAKCC_CC_INSTALLATION_PATH` to the program directly.
 
-The patch map is built from your favorites and aliases; context windows come from provider metadata. A pristine 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 — then the binary is restored first and re-patched fresh. `clodex claude` checks patch freshness at launch and offers to re-patch (a non-blocking notice when not interactive). Re-run `clodex patch` after every `claude` update.
+The patch map is built from your favorites and aliases; context windows come from provider metadata. A pristine per-version backup is kept — recorded against the install it was made for, so a machine with two installs of one Claude Code version restores each from its own bytes — and a manifest (`~/.clodex/patch-state.json`) makes re-runs no-ops until your config or Claude Code version changes — then the binary is restored first and re-patched fresh. `clodex claude` checks patch freshness at launch and offers to re-patch (a non-blocking notice when not interactive). Re-run `clodex patch` after every `claude` update.
 
 #### Local patches (trusted code)
 
@@ -337,7 +337,10 @@ clodex --version    # version
   `CLODEX_CREDENTIAL_HELPER` to an absolute executable path to use an external
   secure store instead; see [credential helpers](docs/credential-helpers.md).
 - Proxied routes forward configured provider headers for API-key and OAuth authentication. Anonymous routes preserve non-credential headers while removing authorization, API-key, cookie, token, secret, and credential-bearing header names before dispatch.
-- `CLODEX_CLAUDE_PATH` overrides Claude Code binary discovery.
+- `CLODEX_CLAUDE_PATH` overrides which Claude Code gets **launched**. It does not choose what
+  `clodex patch` writes to — set `TWEAKCC_CC_INSTALLATION_PATH` for that, and `clodex patch`
+  says so when `CLODEX_CLAUDE_PATH` points somewhere else. The two are separate because a
+  `CLODEX_CLAUDE_PATH` aimed at a wrapper script is right for launching and wrong for patching.
 - **Codex service tier:** `CLODEX_SERVICE_TIER` accepts `fast` (normalized to
   `priority`), `priority`, `flex`, `auto`, or `default`. Clodex requests the
   resolved value only after selecting a ChatGPT/Codex OAuth route; OpenAI

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.12.0",
+  version: "2.12.1",
   publishConfig: {
     access: "public"
   },
@@ -3884,16 +3884,17 @@ function applyClodexPatches(source, config) {
 // src/patcher.ts
 import { createHash as createHash9 } from "crypto";
 import {
+  chmodSync as chmodSync4,
   copyFileSync,
   existsSync as existsSync5,
   mkdtempSync,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync10,
-  renameSync as renameSync2,
-  rmSync,
+  renameSync as renameSync3,
+  rmSync as rmSync2,
   statSync as statSync8,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync6,
   openSync as openSync7,
   closeSync as closeSync7,
   realpathSync as realpathSync2
@@ -7772,7 +7773,7 @@ function writeAll(fd, bytes, position, path) {
 
 // src/patch-backup.ts
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync9, readdirSync, statSync as statSync7 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync9, readdirSync, renameSync as renameSync2, rmSync, statSync as statSync7, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join7 } from "path";
 var BACKUP_SHA_PREFIX_LENGTH = 16;
@@ -7790,9 +7791,60 @@ function backupVersionTag(version) {
 function contentAddressedBackupPath(version, sha256, dir = backupDir()) {
   return join7(dir, `claude-${backupVersionTag(version)}-${sha256.slice(0, BACKUP_SHA_PREFIX_LENGTH)}.orig`);
 }
+function legacyBackupPath(version, dir = backupDir()) {
+  return join7(dir, `claude-${backupVersionTag(version)}.orig`);
+}
 function tweakccMirrorBackupPath(dir = backupDir()) {
   return join7(dir, "native-binary.backup");
 }
+function installProvenancePath(backupPath, binaryPath) {
+  const tag = createHash5("sha256").update(binaryPath).digest("hex").slice(0, BACKUP_SHA_PREFIX_LENGTH);
+  return `${backupPath}.for-${tag}.json`;
+}
+function installProvenancePattern(name) {
+  return new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.for-[0-9a-f]{${BACKUP_SHA_PREFIX_LENGTH}}\\.json$`);
+}
+function readInstallProvenance(path) {
+  let raw;
+  try {
+    raw = readFileSync9(path, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return "damaged";
+  }
+  if (typeof parsed !== "object" || parsed === null) return "damaged";
+  const { install, assumed } = parsed;
+  if (typeof install !== "string" || install === "") return "damaged";
+  if (typeof assumed !== "boolean") return "damaged";
+  return { install, assumed };
+}
+function recordBackupProvenance(backupPath, binaryPath, opts) {
+  const target = installProvenancePath(backupPath, binaryPath);
+  const existing = readInstallProvenance(target);
+  if (existing && existing !== "damaged" && existing.install === binaryPath) {
+    if (existing.assumed === opts.assumed) return existing.assumed ? "assumed" : "established";
+    if (!existing.assumed) return "established";
+  }
+  const record = { install: binaryPath, assumed: opts.assumed };
+  const temp = `${target}.tmp-${process.pid}-${Date.now().toString(36)}`;
+  try {
+    writeFileSync5(temp, `${JSON.stringify(record, null, 2)}
+`);
+    renameSync2(temp, target);
+    return opts.assumed ? "assumed" : "established";
+  } catch (err) {
+    try {
+      rmSync(temp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
 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$`);
@@ -7802,6 +7854,27 @@ function scanPristineBackups(version, dir = backupDir()) {
   } catch {
     return { valid: [], corrupt: [] };
   }
+  const provenanceOf = (name) => {
+    const recordPattern = installProvenancePattern(name);
+    const installs = [];
+    const assumedInstalls = [];
+    const damagedProvenance = [];
+    for (const entry of entries) {
+      if (!recordPattern.test(entry)) continue;
+      const path = join7(dir, entry);
+      const record = readInstallProvenance(path);
+      if (record === null || record === "damaged" || installProvenancePath(join7(dir, name), record.install) !== path) {
+        damagedProvenance.push(path);
+        continue;
+      }
+      (record.assumed ? assumedInstalls : installs).push(record.install);
+    }
+    return {
+      installs: installs.sort(),
+      assumedInstalls: assumedInstalls.sort(),
+      damagedProvenance: damagedProvenance.sort()
+    };
+  };
   const valid = [];
   const corrupt = [];
   for (const entry of entries.sort()) {
@@ -7822,9 +7895,9 @@ function scanPristineBackups(version, dir = backupDir()) {
         corrupt.push(path);
         continue;
       }
-      valid.push({ path, kind: "content-addressed", sha256 });
+      valid.push({ path, kind: "content-addressed", sha256, ...provenanceOf(entry) });
     } else {
-      valid.push({ path, kind: "legacy", sha256 });
+      valid.push({ path, kind: "legacy", sha256, ...provenanceOf(entry) });
     }
   }
   return { valid, corrupt };
@@ -7846,7 +7919,7 @@ function looksLikeLegacyClodexPatch(source) {
 }
 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\`.`;
+  return `clodex holds no pristine backup of claude ${facts.version} it can attribute to ${facts.binaryPath}: none was found in ${backupDir()}${corrupt}. If that binary is patched, reinstall Claude Code to get a pristine one and run \`clodex patch\` again. If it was never patched, there is nothing to restore.`;
 }
 function identifiesABackup(manifest) {
   return manifest.pristineSha256 !== void 0 || manifest.backupPath !== void 0;
@@ -7860,8 +7933,26 @@ function recordedBackupGoneMessage(facts, manifest) {
 function otherInstallMessage(facts, otherBinaryPath) {
   return `The patch manifest records a different Claude Code install (${otherBinaryPath}), so nothing establishes that a pristine backup tagged claude ${facts.version} in ${backupDir()} belongs to ${facts.binaryPath}. Two installs of one Claude Code version are different files, so restoring by version tag alone would overwrite this install with another one's bytes. Set TWEAKCC_CC_INSTALLATION_PATH=${otherBinaryPath} to restore that install instead, or reinstall Claude Code to make this one pristine.`;
 }
+function otherInstallProvenanceMessage(facts, recorded) {
+  const owners = [...new Set(recorded.flatMap((backup) => backup.installs))];
+  return `The pristine backup(s) of claude ${facts.version} in ${backupDir()} are recorded as the pristine content of ${owners.join(", ")}, not of ${facts.binaryPath}. Two installs of one Claude Code version are different files, so restoring one of those would overwrite this install with bytes that were never its own. Set TWEAKCC_CC_INSTALLATION_PATH=${owners[0]} to restore that install instead, or reinstall Claude Code to make this one pristine.`;
+}
+function damagedProvenanceMessage(facts, damaged) {
+  return `A pristine backup of claude ${facts.version} in ${backupDir()} carries a provenance record that clodex cannot read (${damaged.join(", ")}). Something recorded which install those bytes belong to and that record is damaged, so clodex will not fall back to matching on the claude version in the file name \u2014 on a machine with more than one install that would hand ${facts.binaryPath} bytes that were never its own. Delete the unreadable record to accept that fallback, or reinstall Claude Code to make this install pristine.`;
+}
+function contradictoryProvenanceMessage(facts, mine) {
+  return `More than one pristine backup of claude ${facts.version} is recorded as the pristine content of ${facts.binaryPath} (${mine.map((backup) => backup.path).join(", ")}), and they do not hold the same bytes, so clodex cannot tell which one that install holds now \u2014 being snapshotted twice, at two different sets of unpatched bytes, reaches this state without either record being wrong. Delete whichever is stale to decide it: ${mine.map((backup) => installProvenancePath(backup.path, facts.binaryPath)).join(", ")}. Or reinstall the Claude Code at ${facts.binaryPath} and delete both.`;
+}
+function manifestContradictsRecordMessage(facts, manifestChoice, recorded) {
+  return `The patch manifest names ${manifestChoice} as the pristine content of ${facts.binaryPath}, but ${recorded.map((backup) => backup.path).join(", ")} is recorded as that install's pristine content and holds different bytes. Nothing establishes which of them the install at that path is now \u2014 an executable replaced in place with a different build of the same claude version reaches exactly this state \u2014 so clodex will not pick one. Delete whichever of these records is stale to decide it: ${recorded.map((backup) => installProvenancePath(backup.path, facts.binaryPath)).join(", ")}. Or reinstall the Claude Code at ${facts.binaryPath} and delete both: a pristine install needs no backup, and \`clodex patch\` will record its own.`;
+}
+function assumedElsewhereMessage(facts, backups) {
+  const others = [...new Set(backups.flatMap((backup) => backup.assumedInstalls))];
+  return `The pristine backup(s) of claude ${facts.version} in ${backupDir()} have already been restored onto ${others.join(", ")} \u2014 not onto ${facts.binaryPath}. That was itself matched on the claude version in a file name, so it is not proof of ownership, but it is a reason not to hand the same bytes to a second install: two installs of one version are different files. Set TWEAKCC_CC_INSTALLATION_PATH=${others[0]} to restore that install, or reinstall Claude Code to make this one pristine.`;
+}
 function selectRestoreSource(facts) {
   const notes = [];
+  let assumedForThisInstall = false;
   const recorded = facts.manifest;
   const speaksForThisVersion = !recorded?.claudeVersion || recorded.claudeVersion === facts.version;
   const manifest = recorded && recorded.binaryPath === facts.binaryPath && speaksForThisVersion ? recorded : null;
@@ -7873,10 +7964,46 @@ function selectRestoreSource(facts) {
   if (!chosen && manifest && identifiesABackup(manifest)) {
     return { action: "error", message: recordedBackupGoneMessage(facts, manifest) };
   }
+  const manifestDescribesLiveBytes = !!manifest?.patchedSha256 && manifest.patchedSha256 === facts.liveSha256;
+  if (chosen && !manifestDescribesLiveBytes) {
+    const manifestChoice = chosen;
+    const contradicting = facts.backups.filter(
+      (backup) => backup.installs.includes(facts.binaryPath) && backup.sha256 !== manifestChoice.sha256
+    );
+    if (contradicting.length) {
+      return {
+        action: "error",
+        message: manifestContradictsRecordMessage(facts, manifestChoice.path, contradicting)
+      };
+    }
+  }
+  if (!chosen) {
+    const mine = facts.backups.filter((backup) => backup.installs.includes(facts.binaryPath));
+    if (mine.length) {
+      if (new Set(mine.map((backup) => backup.sha256)).size > 1) {
+        return { action: "error", message: contradictoryProvenanceMessage(facts, mine) };
+      }
+      chosen = mine.find((backup) => backup.kind === "content-addressed") ?? mine[0];
+    }
+  }
   if (!chosen) {
     if (other) {
       return facts.backups.length ? { action: "error", message: otherInstallMessage(facts, other.binaryPath) } : { action: "error", message: noBackupMessage(facts) };
     }
+    const recordedElsewhere = facts.backups.filter((backup) => backup.installs.length > 0);
+    if (recordedElsewhere.length) {
+      return { action: "error", message: otherInstallProvenanceMessage(facts, recordedElsewhere) };
+    }
+    const damaged = facts.backups.flatMap((backup) => backup.damagedProvenance);
+    if (damaged.length) {
+      return { action: "error", message: damagedProvenanceMessage(facts, damaged) };
+    }
+    const assumedElsewhere = facts.backups.filter(
+      (backup) => backup.assumedInstalls.some((install) => install !== facts.binaryPath)
+    );
+    if (assumedElsewhere.length) {
+      return { action: "error", message: assumedElsewhereMessage(facts, assumedElsewhere) };
+    }
     const distinct = [...new Set(facts.backups.map((backup) => backup.sha256))];
     if (distinct.length > 1) {
       return {
@@ -7886,12 +8013,14 @@ function selectRestoreSource(facts) {
     }
     chosen = facts.backups.find((backup) => backup.kind === "content-addressed") ?? facts.backups[0];
     if (chosen) {
+      assumedForThisInstall = true;
       notes.push(
-        `No patch manifest records ${facts.binaryPath}, so ${chosen.path} is being used as its pristine content on the strength of its claude ${facts.version} version tag alone. On a machine with more than one Claude Code install those bytes may belong to the other one \u2014 a clodex that had recorded this install would have refused rather than guess.`
+        `Neither a patch manifest nor a provenance record ties ${chosen.path} to ${facts.binaryPath}, so it is being used as that install's pristine content on the strength of its claude ${facts.version} version tag alone \u2014 it predates the records clodex now writes. On a machine with more than one Claude Code install those bytes may belong to the other one, and clodex will not record this guess as provenance.`
       );
     }
   }
   if (!chosen) return { action: "error", message: noBackupMessage(facts) };
+  if (manifest?.pristineProvenance === "assumed") assumedForThisInstall = true;
   return {
     action: "restore",
     backupPath: chosen.path,
@@ -7900,6 +8029,7 @@ function selectRestoreSource(facts) {
     // 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",
+    assumedForThisInstall,
     notes
   };
 }
@@ -13800,7 +13930,7 @@ function readPatchManifest(path = getPatchManifestPath()) {
 }
 function writePatchManifest(manifest, path = getPatchManifestPath()) {
   mkdirSync5(getAppHome(), { recursive: true, mode: 448 });
-  writeFileSync5(path, `${JSON.stringify(manifest, null, 2)}
+  writeFileSync6(path, `${JSON.stringify(manifest, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function buildPatchModelConfig(favorites, aliases, modelMetaFor) {
@@ -13958,7 +14088,7 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
     try {
       const fd = openSync7(lockPath, "wx");
       const content = { pid: process.pid, startedAt: now };
-      writeFileSync5(fd, JSON.stringify(content));
+      writeFileSync6(fd, JSON.stringify(content));
       closeSync7(fd);
       return () => {
         try {
@@ -13983,10 +14113,19 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
   }
   return null;
 }
+var ignoredLaunchOverride = null;
+function takeIgnoredLaunchOverride() {
+  const ignored = ignoredLaunchOverride;
+  ignoredLaunchOverride = null;
+  return ignored;
+}
 function resolveClaudeBinaryForPatch() {
-  const envOverride = process.env["TWEAKCC_CC_INSTALLATION_PATH"];
+  const envOverride = process.env["TWEAKCC_CC_INSTALLATION_PATH"]?.trim() || null;
   const nativeSymlink = join8(homedir3(), ".local", "bin", "claude");
-  const source = envOverride?.trim() || (existsSync5(nativeSymlink) ? nativeSymlink : null) || findClaudeBinary();
+  if (envOverride && !existsSync5(envOverride)) {
+    return { ok: false, reason: "patch-target-missing", declaredPath: envOverride };
+  }
+  const source = envOverride || (existsSync5(nativeSymlink) ? nativeSymlink : null) || findClaudeBinary();
   if (!source) return { ok: false, reason: "binary-not-found" };
   let resolved;
   try {
@@ -14006,6 +14145,17 @@ function resolveClaudeBinaryForPatch() {
     };
   }
   resolved = followed.path;
+  const launchOverride = process.env["CLODEX_CLAUDE_PATH"]?.trim() || null;
+  let launchOverrideResolved = null;
+  if (launchOverride) {
+    try {
+      const followedOverride = resolveThroughNpmShims(realpathSync2(launchOverride));
+      launchOverrideResolved = followedOverride.ok ? followedOverride.path : realpathSync2(launchOverride);
+    } catch {
+      launchOverrideResolved = launchOverride;
+    }
+  }
+  ignoredLaunchOverride = launchOverrideResolved && launchOverrideResolved !== resolved ? { used: resolved, ignored: launchOverride } : null;
   try {
     if (!statSync8(resolved).isFile()) return { ok: false, reason: "binary-not-found" };
   } catch {
@@ -14029,7 +14179,7 @@ function installScriptCommand(path) {
 }
 function describePatchTargetFailure(target, command = "patch") {
   if (target.reason === "launcher-unresolved") {
-    return `${target.shimPath} starts Claude Code but is not Claude Code itself, and clodex could not follow it: ${target.detail}. clodex will not patch a launcher script \u2014 that fails with "Unable to detect installation type". Set CLODEX_CLAUDE_PATH to the Claude Code program itself (for an npm install on Windows that is node_modules\\@anthropic-ai\\claude-code\\bin\\claude.exe under the directory holding the launcher), then run the command again.`;
+    return `${target.shimPath} starts Claude Code but is not Claude Code itself, and clodex could not follow it: ${target.detail}. clodex will not patch a launcher script \u2014 that fails with "Unable to detect installation type". Set TWEAKCC_CC_INSTALLATION_PATH to the Claude Code program itself (for an npm install on Windows that is node_modules\\@anthropic-ai\\claude-code\\bin\\claude.exe under the directory holding the launcher), then run the command again.`;
   }
   if (target.reason === "native-binary-missing") {
     const installer = installScriptCommand(target.installScriptPath);
@@ -14038,6 +14188,9 @@ function describePatchTargetFailure(target, command = "patch") {
     const restore = command === "restore" ? ` If you need to restore by hand, pristine backups are in ${backupDir()}.` : "";
     return `${target.binaryPath} is Claude Code's npm placeholder, not its native binary, so the npm install is incomplete. ${remedy} ${retry}${restore} If this is a custom wrapper rather than the npm placeholder, set TWEAKCC_CC_INSTALLATION_PATH to the native Claude Code binary.`;
   }
+  if (target.reason === "patch-target-missing") {
+    return `TWEAKCC_CC_INSTALLATION_PATH is set to ${target.declaredPath}, which does not exist. clodex will not look for another Claude Code instead \u2014 patching or restoring a different install than the one you named is how one install's pristine bytes end up over another's. Point it at the Claude Code program, or unset it to let clodex find your install.`;
+  }
   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) {
@@ -14060,14 +14213,15 @@ function verifyPristineSource(plan, version) {
     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) {
+function publishFileByRename(from, to, mode) {
   const temp = `${to}.tmp-${process.pid}-${Date.now().toString(36)}`;
   try {
     copyFileSync(from, temp);
-    renameSync2(temp, to);
+    if (mode !== void 0) chmodSync4(temp, mode);
+    renameSync3(temp, to);
   } catch (err) {
     try {
-      rmSync(temp, { force: true });
+      rmSync2(temp, { force: true });
     } catch {
     }
     throw err;
@@ -14131,6 +14285,7 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
   let patchedSha256;
   let backup;
   let pristineSha256;
+  const pristine = { provenance: "established" };
   try {
     mkdirSync5(backupDir(), { recursive: true });
     const { tryDetectInstallation, readContent, writeContent } = await import("tweakcc");
@@ -14179,6 +14334,18 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     }
     pristineSha256 = plan.pristineSha256;
     backup = plan.backupPath;
+    const inheritsAGuess = (path) => {
+      const existing = readInstallProvenance(installProvenancePath(path, binaryPath));
+      return existing === "damaged" || existing !== null && existing.assumed;
+    };
+    const provenanceAssumed = plan.action === "restore" && plan.assumedForThisInstall || inheritsAGuess(plan.backupPath) || inheritsAGuess(contentAddressedBackupPath(version, plan.pristineSha256)) || inheritsAGuess(legacyBackupPath(version)) || facts.backups.some(
+      (candidate) => candidate.sha256 === plan.pristineSha256 && candidate.assumedInstalls.includes(binaryPath)
+    );
+    const recordProvenance = (path) => {
+      if (recordBackupProvenance(path, binaryPath, { assumed: provenanceAssumed }) === "assumed") {
+        pristine.provenance = "assumed";
+      }
+    };
     if (!loaded) {
       loaded = await seedCandidate(backup);
       if (isPatchedClaudeSource(loaded.source)) {
@@ -14190,17 +14357,22 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
           `the patch candidate no longer matches the pristine bytes it was seeded from; refusing to publish it as ${plan.backupPath}`
         );
       }
-      publishBackupFile(candidatePath, plan.backupPath);
+      recordProvenance(plan.backupPath);
+      publishFileByRename(candidatePath, plan.backupPath);
     }
     const canonical = contentAddressedBackupPath(version, pristineSha256);
     if (canonical !== backup) {
+      recordProvenance(backup);
+      recordProvenance(canonical);
       const alreadyStored = facts.backups.some(
         (candidate) => candidate.path === canonical && candidate.sha256 === pristineSha256
       );
-      if (!alreadyStored) publishBackupFile(backup, canonical);
+      if (!alreadyStored) publishFileByRename(backup, canonical);
       backup = canonical;
     }
-    publishBackupFile(backup, tweakccMirrorBackupPath());
+    publishFileByRename(backup, tweakccMirrorBackupPath());
+    recordProvenance(backup);
+    if (plan.backupPath !== backup) recordProvenance(plan.backupPath);
     const builtIn = applyClodexPatches(loaded.source, desired.config);
     results = builtIn.results;
     const failedEffortPatches = requiredEffortPatchFailures(results);
@@ -14267,7 +14439,7 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     else if (publishedBlob) resignMachOBinary(candidatePath);
     patchedSize = statSync8(candidatePath).size;
     patchedSha256 = sha256File(candidatePath);
-    renameSync2(candidatePath, binaryPath);
+    renameSync3(candidatePath, binaryPath);
   } catch (err) {
     const detailLines = err instanceof PatchApplyError ? summarizePatchResults(err.results) : [];
     if (opts.trace && detailLines.length) {
@@ -14282,7 +14454,7 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
   } finally {
     if (candidateDir !== void 0) {
       try {
-        rmSync(candidateDir, { recursive: true, force: true });
+        rmSync2(candidateDir, { recursive: true, force: true });
       } catch (err) {
         if (opts.trace) {
           process.stderr.write(
@@ -14305,6 +14477,7 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     patchedSha256,
     backupPath: backup,
     pristineSha256,
+    ...pristine.provenance === "assumed" ? { pristineProvenance: "assumed" } : {},
     patchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writePatchManifest(manifest);
@@ -14318,7 +14491,7 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
   };
 }
 function runRestoreCommand(target) {
-  if (!target.ok && (target.reason === "binary-not-found" || target.reason === "native-binary-missing")) {
+  if (!target.ok && (target.reason === "binary-not-found" || target.reason === "patch-target-missing" || target.reason === "native-binary-missing")) {
     p2.log.error(describePatchTargetFailure(target, "restore"));
     return 1;
   }
@@ -14353,16 +14526,65 @@ function runRestoreCommand(target) {
     p2.log.error(verified.message);
     return 1;
   }
-  copyFileSync(plan.backupPath, binaryPath);
+  if (manifest && manifest.backupPath && manifest.binaryPath === binaryPath && manifest.claudeVersion !== version && manifest.backupPath !== plan.backupPath) {
+    try {
+      if (existsSync5(manifest.backupPath)) {
+        recordBackupProvenance(manifest.backupPath, manifest.binaryPath, {
+          assumed: manifest.pristineProvenance === "assumed"
+        });
+      }
+    } catch (err) {
+      p2.log.warn(
+        `Could not record in ${backupDir()} that ${manifest.backupPath} holds the pristine bytes of claude ${manifest.claudeVersion} at ${manifest.binaryPath} (${err instanceof Error ? err.message : String(err)}). That version may need to be reinstalled rather than restored.`
+      );
+    }
+  }
+  let recorded;
   try {
-    unlinkSync3(getPatchManifestPath());
+    recorded = recordBackupProvenance(plan.backupPath, binaryPath, { assumed: plan.assumedForThisInstall });
+  } catch (err) {
+    recorded = "failed";
+    const detail = err instanceof Error ? err.message : String(err);
+    if (plan.assumedForThisInstall) {
+      p2.log.error(
+        `Refusing to restore ${binaryPath} from ${plan.backupPath}: nothing but the claude ${version} version tag ties those bytes to this install, and clodex cannot record that in ${backupDir()} (${detail}). Writing them without that record would leave the machine unable to tell afterwards that the match was a guess. Fix the backup directory, or reinstall Claude Code to make this install pristine.`
+      );
+      return 1;
+    }
+    p2.log.warn(
+      `Could not record in ${backupDir()} that ${plan.backupPath} holds the pristine bytes of ${binaryPath} (${detail}). Restoring anyway and keeping the patch manifest, so that record is not lost \u2014 a later restore would otherwise have nothing tying that backup to this install.`
+    );
+  }
+  let publishedMode;
+  try {
+    publishedMode = statSync8(binaryPath).mode;
   } catch {
   }
+  try {
+    publishFileByRename(plan.backupPath, binaryPath, publishedMode);
+  } catch (err) {
+    p2.log.warn(
+      `Could not replace ${binaryPath} through a new file (${err instanceof Error ? err.message : String(err)}); writing the pristine bytes in place instead. If claude then fails to start with a code-signing error, copy the backup to a new file and move it over the binary by hand.`
+    );
+    copyFileSync(plan.backupPath, binaryPath);
+  }
+  if (recorded === "established" && (!manifest || manifest.binaryPath === binaryPath)) {
+    try {
+      unlinkSync3(getPatchManifestPath());
+    } catch {
+    }
+  }
   p2.log.success(`Restored pristine claude ${version} from ${plan.backupPath}.`);
   return 0;
 }
 async function runPatchCommand(opts = {}) {
   const target = resolveClaudeBinaryForPatch();
+  const ignoredOverride = takeIgnoredLaunchOverride();
+  if (ignoredOverride) {
+    p2.log.warn(
+      `CLODEX_CLAUDE_PATH is set to ${ignoredOverride.ignored}, but it does not choose what gets patched \u2014 ${ignoredOverride.used} does. CLODEX_CLAUDE_PATH selects the claude that gets LAUNCHED; set TWEAKCC_CC_INSTALLATION_PATH to patch a specific install.`
+    );
+  }
   if (opts.restore) return runRestoreCommand(target);
   if (!target.ok) {
     p2.log.error(describePatchTargetFailure(target));
@@ -14405,6 +14627,19 @@ async function runPatchCommand(opts = {}) {
     p2.log.warn("Another clodex process is patching the claude binary right now \u2014 skipped.");
     return 1;
   }
+  if (manifest && manifest.backupPath && (manifest.binaryPath !== binaryPath || manifest.claudeVersion !== version)) {
+    try {
+      if (existsSync5(manifest.backupPath)) {
+        recordBackupProvenance(manifest.backupPath, manifest.binaryPath, {
+          assumed: manifest.pristineProvenance === "assumed"
+        });
+      }
+    } catch (err) {
+      p2.log.warn(
+        `Could not record in ${backupDir()} that ${manifest.backupPath} holds the pristine bytes of ${manifest.binaryPath} before replacing the patch manifest (${err instanceof Error ? err.message : String(err)}). That install may need to be reinstalled rather than restored.`
+      );
+    }
+  }
   try {
     const outcome = await applyPatch(binaryPath, version, desired, configHash, {
       trace: opts.trace ?? false,
@@ -14794,9 +15029,9 @@ import {
   mkdirSync as mkdirSync6,
   openSync as openSync8,
   readFileSync as readFileSync11,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { dirname as dirname6 } from "path";
 var JOURNAL_SCHEMA_VERSION = 1;
@@ -14928,13 +15163,13 @@ function writeJournalUnlocked(journal, path) {
   let fd;
   try {
     fd = openSync8(tmp, "wx", FILE_MODE4);
-    writeFileSync6(fd, `${JSON.stringify(journal, null, 2)}
+    writeFileSync7(fd, `${JSON.stringify(journal, null, 2)}
 `);
     fsyncSync2(fd);
     closeSync8(fd);
     fd = void 0;
     assertRegistryWriteOwnership(path);
-    renameSync3(tmp, path);
+    renameSync4(tmp, path);
     syncParentDirectory(path);
   } finally {
     if (fd !== void 0) closeSync8(fd);
@@ -18907,7 +19142,7 @@ import { createBrotliDecompress, createGunzip, createInflate } from "zlib";
 
 // src/http-proxy/ca.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { chmodSync as chmodSync4, existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync as chmodSync5, existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname7, join as join9, resolve as resolve3 } from "path";
 import forge from "node-forge";
 var CERT_DIR = "http-proxy";
@@ -18934,16 +19169,16 @@ function certPaths() {
   };
 }
 function writePrivate(path, value) {
-  writeFileSync7(path, value, { encoding: "utf8", mode: 384 });
-  chmodSync4(path, 384);
+  writeFileSync8(path, value, { encoding: "utf8", mode: 384 });
+  chmodSync5(path, 384);
 }
 function writePublic(path, value) {
-  writeFileSync7(path, value, { encoding: "utf8", mode: 420 });
-  chmodSync4(path, 420);
+  writeFileSync8(path, value, { encoding: "utf8", mode: 420 });
+  chmodSync5(path, 420);
 }
 function generateCertificates(paths) {
   mkdirSync7(paths.dir, { recursive: true, mode: 448 });
-  chmodSync4(paths.dir, 448);
+  chmodSync5(paths.dir, 448);
   const caKeys = forge.pki.rsa.generateKeyPair(2048);
   const caCert = forge.pki.createCertificate();
   caCert.publicKey = caKeys.publicKey;