@bman654/clodex 2.11.7 → 2.12.1

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.11.7",
+  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
   };
 }
@@ -8847,7 +8977,7 @@ function instructionChangeSummary(previous, current) {
   const firstDiffLine = previous.slice(0, prefix).split("\n").length;
   return `instructions changed: previous_chars=${previous.length} current_chars=${current.length} common_prefix_chars=${prefix} common_suffix_chars=${suffix} first_diff_line=${firstDiffLine}`;
 }
-function responsesWebSocketPartitionKey(wsUrl, payload, options = {}, authorizationFingerprint = "") {
+function responsesWebSocketPartitionKey(wsUrl, payload, options = {}, authorizationFingerprint = "", claudeAgentId = "") {
   const promptCacheKey = payload.prompt_cache_key;
   const model = payload.model;
   if (typeof promptCacheKey !== "string" || !promptCacheKey || typeof model !== "string" || !model) return void 0;
@@ -8860,7 +8990,8 @@ function responsesWebSocketPartitionKey(wsUrl, payload, options = {}, authorizat
     model,
     effort,
     promptCacheKey,
-    authorizationFingerprint
+    authorizationFingerprint,
+    claudeAgentId
   ].join("");
   return createHash6("sha256").update(material).digest("hex");
 }
@@ -10019,16 +10150,18 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
     }
     if (hasResponsesLiteHeader(headers)) payload = applyResponsesLiteShape(payload);
     const authorizationFingerprint = authorizationHeaderFingerprint(headers);
+    const diagnosticCorrelation = diagnosticContext.getStore();
+    const claudeAgentId = diagnosticCorrelation?.claudeAgentId ?? "";
     const partitionKey = responsesWebSocketPartitionKey(
       wsUrl,
       payload,
       options,
-      authorizationFingerprint
+      authorizationFingerprint,
+      claudeAgentId
     );
     const promptFingerprint = responsesWebSocketPromptFingerprint(payload);
     const promptFieldHashes = responsesWebSocketPromptFieldHashes(payload);
     const instructionsSnapshot = instructionsFromPayload(payload);
-    const diagnosticCorrelation = diagnosticContext.getStore();
     let now = resolvedOptions.now();
     const evictions = cleanupExpiredConnections(now);
     let canonicalClientItems;
@@ -10236,7 +10369,9 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
         accountIdHash: options.accountId ? createHash6("sha256").update(options.accountId).digest("hex").slice(0, 16) : "",
         model: typeof payload.model === "string" ? payload.model : void 0,
         effort: typeof payload.reasoning?.effort === "string" ? String(payload.reasoning.effort).trim().toLowerCase() : "",
-        promptCacheKey: typeof payload.prompt_cache_key === "string" ? payload.prompt_cache_key : void 0
+        promptCacheKey: typeof payload.prompt_cache_key === "string" ? payload.prompt_cache_key : void 0,
+        claudeAgentId: claudeAgentId || void 0,
+        claudeParentAgentId: diagnosticCorrelation?.claudeParentAgentId
       },
       promptFingerprint,
       promptFieldHashes,
@@ -12134,6 +12269,18 @@ function extractClaudeSessionId(body, headerFallback) {
   }
   return validClaudeSessionId(headerFallback);
 }
+var CLAUDE_AGENT_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
+function extractClaudeAgentIds(headers) {
+  const read = (name) => {
+    const raw = headers[name];
+    const value = (Array.isArray(raw) ? raw[0] : raw)?.trim();
+    return value && CLAUDE_AGENT_ID_RE.test(value) ? value : void 0;
+  };
+  return {
+    claudeAgentId: read("x-claude-code-agent-id"),
+    claudeParentAgentId: read("x-claude-code-parent-agent-id")
+  };
+}
 function claudeSessionPromptCacheKey(sessionId) {
   return "relay-session-" + createHash8("sha256").update(sessionId).digest("hex").slice(0, 32);
 }
@@ -13345,6 +13492,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
         const openAiOAuth = isOpenAiOAuthRoute(route);
         const claudeSessionIdHeader = Array.isArray(req.headers["x-claude-code-session-id"]) ? req.headers["x-claude-code-session-id"][0] : req.headers["x-claude-code-session-id"];
         const claudeSessionId = extractClaudeSessionId(anthropicBody, claudeSessionIdHeader);
+        const claudeAgentIds = extractClaudeAgentIds(req.headers);
         const translationLifecycle = createTranslationLifecycle(
           inferenceLogPath,
           relayRequestId,
@@ -13418,7 +13566,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
             keepAlive.unref();
             try {
               await withResponsesWebSocketDiagnosticContext(
-                { requestId: relayRequestId, claudeSessionId },
+                { requestId: relayRequestId, claudeSessionId, ...claudeAgentIds },
                 () => streamAnthropicResponse(
                   model,
                   params,
@@ -13449,7 +13597,7 @@ async function startProxyCatalog(routes, defaultAliasId, debug = false, inferenc
             res.end();
           } else {
             const anthropicResponse = await withResponsesWebSocketDiagnosticContext(
-              { requestId: relayRequestId, claudeSessionId },
+              { requestId: relayRequestId, claudeSessionId, ...claudeAgentIds },
               () => generateAnthropicResponse(
                 model,
                 params,
@@ -13782,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) {
@@ -13940,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 {
@@ -13965,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 {
@@ -13988,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 {
@@ -14011,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);
@@ -14020,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) {
@@ -14042,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;
@@ -14113,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");
@@ -14161,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)) {
@@ -14172,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);
@@ -14249,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) {
@@ -14264,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(
@@ -14287,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);
@@ -14300,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;
   }
@@ -14335,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 {
+    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 {
-    unlinkSync3(getPatchManifestPath());
+    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));
@@ -14387,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,
@@ -14776,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;
@@ -14910,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);
@@ -18218,6 +18471,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
   const requestId = randomUUID5();
   const claudeSessionIdHeader = Array.isArray(req.headers["x-claude-code-session-id"]) ? req.headers["x-claude-code-session-id"][0] : req.headers["x-claude-code-session-id"];
   const claudeSessionId = extractClaudeSessionId(body, claudeSessionIdHeader);
+  const claudeAgentIds = extractClaudeAgentIds(req.headers);
   if (options.webSocketDiagnosticsLogPath) {
     writeWebSocketDiagnosticRequestLog(options.webSocketDiagnosticsLogPath, {
       requestId,
@@ -18382,7 +18636,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
             res.write(chunk);
           };
           await withResponsesWebSocketDiagnosticContext(
-            { requestId, claudeSessionId },
+            { requestId, claudeSessionId, ...claudeAgentIds },
             () => streamAnthropicResponse(languageModel, params, responseModelId, writeStreamChunk, void 0, {
               abortSignal: clientAbort.signal,
               initialInputTokens: estimateAnthropicInputTokens(body),
@@ -18398,7 +18652,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
           res.end();
         } else {
           const anthropicResponse = await withResponsesWebSocketDiagnosticContext(
-            { requestId, claudeSessionId },
+            { requestId, claudeSessionId, ...claudeAgentIds },
             () => generateAnthropicResponse(languageModel, params, responseModelId, {
               forceStream: openAiOAuth,
               abortSignal: clientAbort.signal,
@@ -18888,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";
@@ -18915,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;
@@ -19491,6 +19745,9 @@ function forwardToAdapter(req, res, rawBody, adapter, adapterRequest = http2.req
         "Content-Length": String(rawBody.length),
         "x-api-key": adapter.token,
         ...typeof req.headers["x-claude-code-session-id"] === "string" ? { "x-claude-code-session-id": req.headers["x-claude-code-session-id"] } : {},
+        // Subagent identity: the relay partitions ChatGPT WebSocket heads by it.
+        ...typeof req.headers["x-claude-code-agent-id"] === "string" ? { "x-claude-code-agent-id": req.headers["x-claude-code-agent-id"] } : {},
+        ...typeof req.headers["x-claude-code-parent-agent-id"] === "string" ? { "x-claude-code-parent-agent-id": req.headers["x-claude-code-parent-agent-id"] } : {},
         ...lifecycle ? { "x-relay-request-id": lifecycle.requestId } : {}
       }
     }, (upstreamRes) => {