@bman654/clodex 2.13.1 → 2.14.0

package/README.md

@@ -107,7 +107,7 @@ flowchart LR
 > Using Claude Code's agents view or background agents? Ask your Claude Code agent to read [docs/background-agents.md](docs/background-agents.md) and set it up for you — one global `clodex server --proxy` plus the `clodex-claude` wrapper bin bridges every claude process automatically.
 
 > [!TIP]
-> On Windows with the Claude Code VS Code extension? See [docs/windows-setup.md](docs/windows-setup.md) — proxy-mode env vars route the extension through clodex, and an optional process wrapper makes clodex models appear in its model picker.
+> Using the Claude Code VS Code extension? `clodex-claude` launches your verified clodex-patched install in place of the extension's bundled binary, so clodex models appear in its model picker; follow the [VS Code setup](docs/background-agents.md#vs-code-model-picker). On Windows, `clodex install-vscode-launcher` first builds the `.exe` the extension needs to launch Claude Code through `clodex-claude`; see [docs/windows-setup.md](docs/windows-setup.md).
 
 ## CLI reference
 
@@ -146,7 +146,7 @@ Common options (both modes):
 | `--save-mode` | With `--endpoint`/`--proxy`: save that mode as the `server` default |
 | `--port <1-65535>` | Listen port (default 17645) |
 | `--no-discovery` | Don't advertise this server in `~/.clodex/server-runtime.json` (`CLODEX_NO_DISCOVERY=1` also works). Use it for a standalone endpoint the `clodex-claude` wrapper should ignore. |
-| `--ws-diagnostics` | Log sanitized request envelopes and WebSocket head decisions |
+| `--ws-diagnostics` | Log sanitized request envelopes and WebSocket head decisions, plus the usage-limit reports the OpenAI socket sends, verbatim (they include account state such as credits) |
 | `--help`, `--version` | Help / version |
 
 Endpoint mode only (an error if combined with `--proxy`):
@@ -293,6 +293,10 @@ Two things worth knowing about the numbers:
 
 Providers supported: `openai` (API key, platform.openai.com), `openai-oauth` (ChatGPT/Codex plan), and `opencode-go` (OpenCode Go API key). OpenCode Go exposes its Anthropic Messages and Chat Completions models; Responses-only entries are intentionally excluded. See [OpenCode Go provider](docs/opencode-go.md).
 
+### `clodex install-vscode-launcher`
+
+Windows only. Builds `%USERPROFILE%\.clodex\bin\clodex-claude.exe`, the executable the Claude Code VS Code extension can use as its `claudeCode.claudeProcessWrapper`, so chats in the editor launch Claude Code through `clodex-claude` (on Windows npm installs that wrapper as three script shims — extensionless, `.cmd`, `.ps1` — and no executable the extension can spawn). It compiles a short C# source shipped in the package with the compiler already inside the .NET Framework — nothing is downloaded — and prints the setting to paste; it never edits VS Code or Claude settings. The paths to `node.exe` and the clodex install are compiled in, so re-run it after switching Node versions or moving clodex. Setup guide: [docs/windows-setup.md](docs/windows-setup.md).
+
 ### Root
 
 ```

package/dist/{chunk-ZM2KYLPH.js → chunk-3NCDMS7N.js}

@@ -1372,6 +1372,62 @@ async function listenTcpServer(server, port, host) {
   );
 }
 
+// src/parent-notice.ts
+import { writeSync as writeSync2 } from "fs";
+var MAX_NOTICE_CHARS = 2e3;
+var CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
+var activeSink = null;
+var stderrErrorGuardInstalled = false;
+function toNoticeLine(message) {
+  const flattened = message.replace(CONTROL_CHARS, " ").trimEnd();
+  const bounded = flattened.length > MAX_NOTICE_CHARS ? `${flattened.slice(0, MAX_NOTICE_CHARS)}...` : flattened;
+  return `${bounded}
+`;
+}
+function guardStderrErrors() {
+  if (stderrErrorGuardInstalled) return;
+  stderrErrorGuardInstalled = true;
+  try {
+    process.stderr.on("error", () => {
+    });
+  } catch {
+  }
+}
+function writeParentNoticeLines(lines) {
+  if (lines.length === 0) return;
+  guardStderrErrors();
+  try {
+    process.stderr.write(lines.join(""), () => {
+    });
+  } catch {
+  }
+}
+function writeParentNoticeLinesSync(lines) {
+  if (lines.length === 0) return;
+  try {
+    writeSync2(2, lines.join(""));
+  } catch {
+  }
+}
+function emitParentNotice(message) {
+  const line = toNoticeLine(message);
+  try {
+    if (activeSink) activeSink(line);
+    else writeParentNoticeLines([line]);
+  } catch {
+  }
+}
+function installParentNoticeSink(sink) {
+  const previous = activeSink;
+  activeSink = sink;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    if (activeSink === sink) activeSink = previous;
+  };
+}
+
 // src/server-runtime.ts
 import {
   closeSync as closeSync3,
@@ -1626,6 +1682,9 @@ function recordNetworkEnvMutation(baseline, injectedEnv) {
 
 // src/wrapper-env.ts
 var REQUIRE_SERVER_ENV = "CLODEX_REQUIRE_SERVER";
+function wrapperSpawnShell(platform, target) {
+  return platform === "win32" && /\.(cmd|bat)$/i.test(target);
+}
 function removeAnthropicProxyBypass(env) {
   const noProxyValues = [env["NO_PROXY"], env["no_proxy"]].filter((value) => value !== void 0);
   if (noProxyValues.length === 0) return;
@@ -1649,6 +1708,16 @@ var LOCAL_GATEWAY_API_KEY = "clodex-local";
 function wrapperRequiresServer(env) {
   return env[REQUIRE_SERVER_ENV] === "1";
 }
+function wrapperIsTopLevelVsCodeHost(env) {
+  return env["CLAUDE_CODE_ENTRYPOINT"] === "claude-vscode" && !env["CLAUDE_CODE_CHILD_SESSION"] && !env["CLAUDECODE"];
+}
+function wrapperSubstitutionEligible(env, state) {
+  return wrapperIsTopLevelVsCodeHost(env) && state?.mode === "proxy";
+}
+function wrapperInvocationIsChat(args) {
+  const streamJson = args.some((arg, index) => arg === "stream-json" && (args[index - 1] === "--output-format" || args[index - 1] === "--input-format"));
+  return streamJson && !args.includes("--no-session-persistence");
+}
 function computeWrapperEnv(baseEnv, state) {
   if (!state) return { ...baseEnv };
   const baseline = networkEnvBaseline(baseEnv);
@@ -1669,6 +1738,378 @@ function computeWrapperEnv(baseEnv, state) {
   return env;
 }
 
+// src/patch-manifest.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+function getPatchManifestPath() {
+  return join5(getAppHome(), "patch-state.json");
+}
+function readPatchManifest(path = getPatchManifestPath()) {
+  try {
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    if (parsed && typeof parsed.binaryPath === "string" && typeof parsed.configHash === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+function readWrapperPatchManifest(path = getPatchManifestPath()) {
+  let raw;
+  try {
+    raw = readFileSync5(path, "utf8");
+  } catch (error) {
+    return error.code === "ENOENT" ? { status: "missing", path } : { status: "invalid", path };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "invalid", path };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { status: "invalid", path };
+  }
+  const value = parsed;
+  const hint = {
+    ...typeof value.binaryPath === "string" && value.binaryPath.trim() ? { binaryPath: value.binaryPath } : {},
+    ...typeof value.claudeVersion === "string" && value.claudeVersion.trim() ? { claudeVersion: value.claudeVersion } : {}
+  };
+  const valid = typeof value.binaryPath === "string" && value.binaryPath.trim().length > 0 && typeof value.claudeVersion === "string" && value.claudeVersion.trim().length > 0 && typeof value.configHash === "string" && value.configHash.trim().length > 0 && typeof value.patchedSize === "number" && Number.isSafeInteger(value.patchedSize) && value.patchedSize >= 0 && typeof value.patchedSha256 === "string" && SHA256_HEX.test(value.patchedSha256) && typeof value.backupPath === "string" && value.backupPath.trim().length > 0 && typeof value.pristineSha256 === "string" && SHA256_HEX.test(value.pristineSha256) && typeof value.patchedAt === "string" && value.patchedAt.trim().length > 0 && (value.pristineProvenance === void 0 || value.pristineProvenance === "assumed");
+  if (!valid) return { status: "invalid", path, ...hint };
+  return { status: "valid", path, manifest: value };
+}
+
+// src/patch-backup.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  closeSync as closeSync4,
+  existsSync as existsSync4,
+  openSync as openSync4,
+  readFileSync as readFileSync6,
+  readSync,
+  readdirSync,
+  renameSync as renameSync4,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+var BACKUP_SHA_PREFIX_LENGTH = 16;
+function backupDir() {
+  return process.env["TWEAKCC_CONFIG_DIR"]?.trim() || join6(homedir3(), ".tweakcc");
+}
+var HASH_CHUNK_BYTES = 1024 * 1024;
+function sha256File(path) {
+  const hash = createHash2("sha256");
+  const buffer = Buffer.allocUnsafe(HASH_CHUNK_BYTES);
+  const fd = openSync4(path, "r");
+  try {
+    let bytesRead;
+    do {
+      bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+      if (bytesRead > 0) hash.update(buffer.subarray(0, bytesRead));
+    } while (bytesRead > 0);
+  } finally {
+    closeSync4(fd);
+  }
+  return hash.digest("hex");
+}
+function backupVersionTag(version) {
+  const tag = version.trim().replace(/[^\w.-]+/g, "_");
+  if (!tag) throw new Error("clodex patch: refusing to name a pristine backup for an empty claude version");
+  return tag;
+}
+function contentAddressedBackupPath(version, sha256, dir = backupDir()) {
+  return join6(dir, `claude-${backupVersionTag(version)}-${sha256.slice(0, BACKUP_SHA_PREFIX_LENGTH)}.orig`);
+}
+function legacyBackupPath(version, dir = backupDir()) {
+  return join6(dir, `claude-${backupVersionTag(version)}.orig`);
+}
+function tweakccMirrorBackupPath(dir = backupDir()) {
+  return join6(dir, "native-binary.backup");
+}
+function installProvenancePath(backupPath, binaryPath) {
+  const tag = createHash2("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 = readFileSync6(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 {
+    writeFileSync3(temp, `${JSON.stringify(record, null, 2)}
+`);
+    renameSync4(temp, target);
+    return opts.assumed ? "assumed" : "established";
+  } catch (err) {
+    try {
+      rmSync2(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$`);
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } 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 = join6(dir, entry);
+      const record = readInstallProvenance(path);
+      if (record === null || record === "damaged" || installProvenancePath(join6(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()) {
+    const match = pattern.exec(entry);
+    if (!match) continue;
+    const path = join6(dir, entry);
+    let sha256;
+    try {
+      if (!statSync2(path).isFile()) continue;
+      sha256 = sha256File(path);
+    } catch {
+      corrupt.push(path);
+      continue;
+    }
+    const embedded = match[1];
+    if (embedded) {
+      if (sha256.slice(0, BACKUP_SHA_PREFIX_LENGTH) !== embedded) {
+        corrupt.push(path);
+        continue;
+      }
+      valid.push({ path, kind: "content-addressed", sha256, ...provenanceOf(entry) });
+    } else {
+      valid.push({ path, kind: "legacy", sha256, ...provenanceOf(entry) });
+    }
+  }
+  return { valid, corrupt };
+}
+var CLODEX_PATCH_COMMENT_PREFIX = "/*ccpatch:";
+var LEGACY_CLODEX_PATCH_MARKERS = [
+  "Additional custom models: ",
+  // PATCH 4 — Agent tool model description
+  "function(_i){return _i.value===_o.value}",
+  // PATCH 5 — picker dedupe guard
+  '"clodex:'
+  // PATCH 1/3 — canonical ids as model identities
+];
+function isPatchedClaudeSource(source) {
+  return source.includes(CLODEX_PATCH_COMMENT_PREFIX);
+}
+function looksLikeLegacyClodexPatch(source) {
+  return !isPatchedClaudeSource(source) && LEGACY_CLODEX_PATCH_MARKERS.some((marker) => source.includes(marker));
+}
+function noBackupMessage(facts) {
+  const corrupt = facts.corruptBackups?.length ? ` (${facts.corruptBackups.length} backup file(s) for this version failed integrity checks and were ignored)` : "";
+  return `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;
+}
+function recordedBackupGoneMessage(facts, manifest) {
+  const named = manifest.backupPath ?? `the backup holding sha256 ${manifest.pristineSha256}`;
+  const corrupt = facts.corruptBackups?.length ? ` (${facts.corruptBackups.length} backup file(s) for this version failed integrity checks and were ignored)` : "";
+  const others = facts.backups.length ? `The ${facts.backups.length} other pristine backup(s) tagged claude ${facts.version} there were made for some other install \u2014 two installs of one Claude Code version are different files, so restoring one of them would overwrite this install with bytes that were never its own. ` : "";
+  return `The patch manifest records ${named} as the pristine content of ${facts.binaryPath}, and clodex cannot use it: it is missing from ${backupDir()}, failed its integrity check, or holds a different claude version${corrupt}. ${others}Reinstall Claude Code to get a pristine binary, then run \`clodex patch\`.`;
+}
+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;
+  const other = recorded && recorded.binaryPath !== facts.binaryPath && speaksForThisVersion ? recorded : null;
+  let chosen = manifest?.pristineSha256 ? facts.backups.find((backup) => backup.sha256 === manifest.pristineSha256) : void 0;
+  if (!chosen && manifest?.backupPath) {
+    chosen = facts.backups.find((backup) => backup.path === manifest.backupPath);
+  }
+  if (!chosen && 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 {
+        action: "error",
+        message: `Found conflicting pristine backups for claude ${facts.version}: ${facts.backups.map((backup) => backup.path).join(", ")}. They do not hold the same bytes, so clodex cannot tell which one is pristine. If this machine has more than one Claude Code install, both are probably genuine \u2014 one per install \u2014 and deleting either one is a guess. Reinstall the Claude Code at ${facts.binaryPath} instead: a pristine install needs no backup, and \`clodex patch\` will record its own.`
+      };
+    }
+    chosen = facts.backups.find((backup) => backup.kind === "content-addressed") ?? facts.backups[0];
+    if (chosen) {
+      assumedForThisInstall = true;
+      notes.push(
+        `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,
+    pristineSha256: chosen.sha256,
+    // A legacy name carries no hash, so its bytes could be anything — including
+    // another version's binary, stored under a mislabeled name by an older
+    // clodex. Executing it is the only evidence available; require it.
+    probeVersion: chosen.kind === "legacy",
+    assumedForThisInstall,
+    notes
+  };
+}
+function planPristineSource(facts) {
+  const identical = facts.backups.find((backup) => backup.sha256 === facts.liveSha256 && backup.kind === "content-addressed") ?? facts.backups.find((backup) => backup.sha256 === facts.liveSha256);
+  if (identical) {
+    return { action: "reuse", backupPath: identical.path, pristineSha256: identical.sha256, notes: [] };
+  }
+  const manifest = facts.manifest;
+  if (manifest && manifest.binaryPath === facts.binaryPath && manifest.patchedSha256 === facts.liveSha256) {
+    return selectRestoreSource(facts);
+  }
+  return { action: "inspect" };
+}
+function planInspectedPristineSource(facts, inspection) {
+  if (inspection.patched) return selectRestoreSource(facts);
+  const notes = [];
+  const conflicting = facts.backups.filter((backup) => backup.sha256 !== facts.liveSha256);
+  if (conflicting.length) {
+    notes.push(
+      `Existing backup(s) for claude ${facts.version} hold different bytes (${conflicting.map((b) => b.path).join(", ")}); the binary being patched carries no clodex patch marker, so it is being stored under its own content address. Both files are kept.`
+    );
+  }
+  return {
+    action: "snapshot",
+    backupPath: contentAddressedBackupPath(facts.version, facts.liveSha256),
+    pristineSha256: facts.liveSha256,
+    notes
+  };
+}
+function planRestoreOnly(facts) {
+  return selectRestoreSource(facts);
+}
+function collectPristineFacts(args) {
+  const dir = args.dir ?? backupDir();
+  const scan = scanPristineBackups(args.version, dir);
+  return {
+    version: args.version,
+    binaryPath: args.binaryPath,
+    liveSha256: existsSync4(args.binaryPath) ? sha256File(args.binaryPath) : "",
+    manifest: args.manifest,
+    backups: scan.valid,
+    corruptBackups: scan.corrupt
+  };
+}
+
 export {
   OAUTH_ACCOUNT_ENV,
   getAppHome,
@@ -1714,6 +2155,10 @@ export {
   waitForTcpListenerCandidate,
   waitForTcpListener,
   listenTcpServer,
+  writeParentNoticeLines,
+  writeParentNoticeLinesSync,
+  emitParentNotice,
+  installParentNoticeSink,
   isDiscoveryDisabled,
   registerServerRuntimeState,
   unregisterServerRuntimeState,
@@ -1723,8 +2168,29 @@ export {
   NETWORK_ENV_CONTRACT_VAR,
   networkEnvBaseline,
   recordNetworkEnvMutation,
+  wrapperSpawnShell,
   removeAnthropicProxyBypass,
   wrapperRequiresServer,
-  computeWrapperEnv
+  wrapperIsTopLevelVsCodeHost,
+  wrapperSubstitutionEligible,
+  wrapperInvocationIsChat,
+  computeWrapperEnv,
+  getPatchManifestPath,
+  readPatchManifest,
+  readWrapperPatchManifest,
+  backupDir,
+  sha256File,
+  contentAddressedBackupPath,
+  legacyBackupPath,
+  tweakccMirrorBackupPath,
+  installProvenancePath,
+  readInstallProvenance,
+  recordBackupProvenance,
+  isPatchedClaudeSource,
+  looksLikeLegacyClodexPatch,
+  planPristineSource,
+  planInspectedPristineSource,
+  planRestoreOnly,
+  collectPristineFacts
 };
-//# sourceMappingURL=chunk-ZM2KYLPH.js.map
+//# sourceMappingURL=chunk-3NCDMS7N.js.map