@bman654/clodex 2.13.1 → 2.14.0

package/dist/cli.js

@@ -6,7 +6,11 @@ import {
   OAUTH_ACCOUNT_NAME_RE,
   REGISTRY_SCHEMA_VERSION_WITH_MATERIALIZED_ACTIVE_ACCOUNT,
   assertRegistryWriteOwnership,
+  backupDir,
   clearActiveOAuthAccount,
+  collectPristineFacts,
+  contentAddressedBackupPath,
+  emitParentNotice,
   ensureSecureAppHome,
   findClaudeBinary,
   getAppHome,
@@ -18,20 +22,32 @@ import {
   getLocalPatchesPath,
   getLogsPath,
   getOAuthAccountSlot,
+  getPatchManifestPath,
   getSavedServerPassword,
   getServerExposedProviders,
   getServerFavoritesOnly,
   getServerListenMode,
   getServerMaskGatewayIds,
+  installParentNoticeSink,
+  installProvenancePath,
   isDiscoveryDisabled,
+  isPatchedClaudeSource,
   isValidProviderId,
+  legacyBackupPath,
   listenTcpServer,
   loadPreferences,
   loadRegistry,
   loadRegistryStrict,
+  looksLikeLegacyClodexPatch,
   networkEnvBaseline,
+  planInspectedPristineSource,
+  planPristineSource,
+  planRestoreOnly,
   providerDefaultAuthRef,
+  readInstallProvenance,
   readLiveServerRuntimeStates,
+  readPatchManifest,
+  recordBackupProvenance,
   recordLaunchSelection,
   recordNetworkEnvMutation,
   registerServerRuntimeState,
@@ -44,15 +60,19 @@ import {
   setServerFavoritesOnly,
   setServerListenMode,
   setServerMaskGatewayIds,
+  sha256File,
   storeActiveOAuthAccount,
   tcpListenerUrlHost,
+  tweakccMirrorBackupPath,
   unregisterServerRuntimeState,
   waitForTcpListener,
   withCredentialMutationLock,
   withProviderMutationLock,
   withRegistryWriteLock,
-  withRegistryWriteLockSync
-} from "./chunk-ZM2KYLPH.js";
+  withRegistryWriteLockSync,
+  writeParentNoticeLines,
+  writeParentNoticeLinesSync
+} from "./chunk-3NCDMS7N.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -228,69 +248,11 @@ function printFavoritesOnlyPanel() {
 // src/cli.ts
 import * as p12 from "@clack/prompts";
 import { realpathSync as realpathSync3 } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/launch.ts
 import { spawn } from "child_process";
 import { appendFileSync } from "fs";
-
-// src/parent-notice.ts
-import { writeSync } 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 {
-    writeSync(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/launch.ts
 var isWindows = process.platform === "win32";
 var MAX_QUEUED_NOTICES = 50;
 function buildClaudeArgs(model, extraArgs) {
@@ -382,7 +344,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.13.1",
+  version: "2.14.0",
   publishConfig: {
     access: "public"
   },
@@ -411,6 +373,7 @@ var package_default = {
   files: [
     "dist",
     "docs",
+    "launcher",
     "README.md"
   ],
   engines: {
@@ -3882,25 +3845,25 @@ function applyClodexPatches(source, config) {
 }
 
 // src/patcher.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import {
   chmodSync as chmodSync4,
   copyFileSync,
-  existsSync as existsSync5,
+  existsSync as existsSync4,
   mkdtempSync,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync10,
-  renameSync as renameSync3,
-  rmSync as rmSync2,
-  statSync as statSync8,
+  readFileSync as readFileSync9,
+  renameSync as renameSync2,
+  rmSync,
+  statSync as statSync7,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync6,
+  writeFileSync as writeFileSync5,
   openSync as openSync8,
   closeSync as closeSync8,
   realpathSync as realpathSync2
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename, dirname as dirname5, join as join8 } from "path";
+import { homedir as homedir2 } from "os";
+import { basename, dirname as dirname5, join as join7 } from "path";
 import pc3 from "picocolors";
 import * as p2 from "@clack/prompts";
 
@@ -7052,9 +7015,9 @@ function getPlatformKey() {
   return `${platform}-${cpu}`;
 }
 function inspectNativePackage(binaryPath) {
-  const packageRoot = dirname4(dirname4(binaryPath));
-  const packageJsonPath = join6(packageRoot, "package.json");
-  const installScriptPath = join6(packageRoot, "install.cjs");
+  const packageRoot2 = dirname4(dirname4(binaryPath));
+  const packageJsonPath = join6(packageRoot2, "package.json");
+  const installScriptPath = join6(packageRoot2, "install.cjs");
   let manifest;
   try {
     manifest = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
@@ -7110,7 +7073,7 @@ function inspectClaudeNativeBinaryPlaceholder(path) {
 }
 
 // src/bun-entry-module.ts
-import { closeSync as closeSync3, openSync as openSync3, readSync as readSync2, statSync as statSync6, writeSync as writeSync2 } from "fs";
+import { closeSync as closeSync3, openSync as openSync3, readSync as readSync2, statSync as statSync6, writeSync } from "fs";
 import { execFileSync } from "child_process";
 var BUN_TRAILER = Buffer.from("\n---- Bun! ----\n");
 var BUN_OFFSETS_BYTES = 32;
@@ -7275,7 +7238,7 @@ function isModuleNameAt(fd, offset, marker) {
 }
 function writeNameBytes(fd, name, offset) {
   const bytes = Buffer.from(name);
-  const written = writeSync2(fd, bytes, 0, bytes.length, offset);
+  const written = writeSync(fd, bytes, 0, bytes.length, offset);
   if (written !== bytes.length) {
     throw new Error(`wrote ${written} of ${bytes.length} entry-module name bytes at ${offset}`);
   }
@@ -7372,7 +7335,7 @@ function resignMachOBinary(path) {
 }
 
 // src/bun-compiled-pointer.ts
-import { closeSync as closeSync4, fstatSync as fstatSync2, openSync as openSync4, readSync as readSync3, writeSync as writeSync3 } from "fs";
+import { closeSync as closeSync4, fstatSync as fstatSync2, openSync as openSync4, readSync as readSync3, writeSync as writeSync2 } from "fs";
 var TWEAKCC_SCAN_STRIDE = 16384n;
 var SCAN_CHUNK = 1 << 20;
 var ELF_MAGIC = 1179403647;
@@ -7540,7 +7503,7 @@ function shimBunCompiledPointer(path) {
     const standInOffset = Number(segment.offset + (standInVaddr - segment.vaddr));
     const displaced = readAt2(fd, 8, standInOffset);
     if (displaced.length !== 8) throw new Error("could not read the bytes Bun's blob pointer displaces");
-    writeSync3(fd, needle, 0, 8, standInOffset);
+    writeSync2(fd, needle, 0, 8, standInOffset);
     return { pointerVaddr, standInVaddr, displaced, bunVaddr: bun.addr };
   } finally {
     closeSync4(fd);
@@ -7575,8 +7538,8 @@ function restoreBunCompiledPointer(path, shim) {
     }
     const value = Buffer.alloc(8);
     value.writeBigUInt64LE(written);
-    writeSync3(fd, value, 0, 8, pointerOffset);
-    writeSync3(fd, shim.displaced, 0, 8, standInOffset);
+    writeSync2(fd, value, 0, 8, pointerOffset);
+    writeSync2(fd, shim.displaced, 0, 8, standInOffset);
     if (!readAt2(fd, 8, pointerOffset).equals(value)) {
       throw new Error("Bun's blob pointer did not take the repacked address");
     }
@@ -7589,7 +7552,7 @@ function restoreBunCompiledPointer(path, shim) {
 }
 
 // src/bun-bundle.ts
-import { closeSync as closeSync5, openSync as openSync5, readSync as readSync4, writeSync as writeSync4 } from "fs";
+import { closeSync as closeSync5, openSync as openSync5, readSync as readSync4, writeSync as writeSync3 } from "fs";
 function writableModuleIndex(path) {
   const table = readBunModuleTable(path);
   if (!table) return null;
@@ -7804,322 +7767,17 @@ function applyBundleWritePlan(path, plan) {
 function writeAll(fd, bytes, position, path) {
   let written = 0;
   while (written < bytes.length) {
-    const wrote = writeSync4(fd, bytes, written, bytes.length - written, position + written);
+    const wrote = writeSync3(fd, bytes, written, bytes.length - written, position + written);
     if (wrote <= 0) throw new Error(`wrote ${written} of ${bytes.length} blob bytes to ${path}`);
     written += wrote;
   }
 }
 
-// src/patch-backup.ts
-import { createHash as createHash5 } from "crypto";
-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;
-function backupDir() {
-  return process.env["TWEAKCC_CONFIG_DIR"]?.trim() || join7(homedir2(), ".tweakcc");
-}
-function sha256File(path) {
-  return createHash5("sha256").update(readFileSync9(path)).digest("hex");
-}
-function backupVersionTag(version) {
-  const tag = version.trim().replace(/[^\w.-]+/g, "_");
-  if (!tag) throw new Error("clodex patch: refusing to name a pristine backup for an empty claude version");
-  return tag;
-}
-function contentAddressedBackupPath(version, sha256, dir = backupDir()) {
-  return join7(dir, `claude-${backupVersionTag(version)}-${sha256.slice(0, BACKUP_SHA_PREFIX_LENGTH)}.orig`);
-}
-function 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$`);
-  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 = 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()) {
-    const match = pattern.exec(entry);
-    if (!match) continue;
-    const path = join7(dir, entry);
-    let sha256;
-    try {
-      if (!statSync7(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
-  };
-}
-
 // src/provider-factory.ts
 import { wrapLanguageModel, extractReasoningMiddleware } from "ai";
 
 // src/oauth/responses-websocket.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { closeSync as closeSync6, openSync as openSync6 } from "fs";
 import { devNull } from "os";
 import { AsyncLocalStorage } from "async_hooks";
@@ -8487,6 +8145,69 @@ function sanitizeToolInput(input, requiredProps) {
   return out;
 }
 
+// src/tool-input-coerce.ts
+var SCALAR_KINDS = /* @__PURE__ */ new Set(["number", "integer", "boolean"]);
+var LOCAL_REF = /^#\/(?:\$defs|definitions)\/([^/]+)$/;
+var MAX_SCHEMA_VISITS = 64;
+function preferredName(kinds) {
+  let compound;
+  let scalar;
+  let hasString = false;
+  for (const kind of kinds) {
+    if (kind === "array" || kind === "object") compound ??= kind;
+    else if (kind === "string") hasString = true;
+    else if (kind !== void 0 && kind !== "null") scalar ??= kind;
+  }
+  return compound ?? (hasString ? "string" : scalar);
+}
+function schemaScalarKind(schema, parameters) {
+  const defs = parameters && typeof parameters === "object" ? parameters.$defs ?? parameters.definitions : void 0;
+  const visited = /* @__PURE__ */ new Set();
+  const resolve4 = (node) => {
+    if (visited.size > MAX_SCHEMA_VISITS || visited.has(node) || !node || typeof node !== "object") return void 0;
+    visited.add(node);
+    const record = node;
+    if (typeof record.type === "string") return record.type;
+    if (Array.isArray(record.type)) {
+      const named = preferredName(record.type.filter((entry) => typeof entry === "string"));
+      if (named !== void 0) return named;
+    }
+    if (typeof record.$ref === "string" && defs && typeof defs === "object") {
+      const match = LOCAL_REF.exec(record.$ref);
+      if (match) return resolve4(defs[match[1]]);
+    }
+    for (const branches of [record.anyOf, record.oneOf]) {
+      if (!Array.isArray(branches)) continue;
+      const named = preferredName(branches.map(resolve4));
+      if (named !== void 0) return named;
+    }
+    return void 0;
+  };
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return void 0;
+  const kind = resolve4(schema);
+  return kind !== void 0 && SCALAR_KINDS.has(kind) ? kind : void 0;
+}
+var DECIMAL_LITERAL = /^[-+]?\d+(\.\d+)?$/;
+var BOOLEAN_LITERAL = /^\uFEFF?[ \t\n\r]*(true|false)[ \t\n\r]*$/;
+var MAX_SIGNIFICANT_DIGITS = 15;
+function significantDigits(decimal) {
+  const [integer = "", fraction = ""] = decimal.replace(/^[-+]/, "").split(".");
+  return integer.replace(/^0+/, "").length + fraction.length;
+}
+function coerceEchoedScalar(value, kind) {
+  if (typeof value !== "string") return value;
+  if (kind === "boolean") {
+    const match = BOOLEAN_LITERAL.exec(value);
+    return match ? match[1] === "true" : value;
+  }
+  const trimmed = value.trim();
+  if (DECIMAL_LITERAL.test(trimmed)) {
+    return significantDigits(trimmed) <= MAX_SIGNIFICANT_DIGITS ? Number(trimmed) : value;
+  }
+  const numeric = Number(value);
+  return Number.isFinite(numeric) && String(numeric) === value ? numeric : value;
+}
+
 // src/upstream-retry.ts
 var UPSTREAM_MAX_RETRIES_ENV = "CLODEX_UPSTREAM_MAX_RETRIES";
 var UPSTREAM_IDLE_TIMEOUT_ENV = "CLODEX_UPSTREAM_IDLE_TIMEOUT_MS";
@@ -8958,7 +8679,7 @@ function hasResponsesLiteHeader(headers) {
 }
 function authorizationHeaderFingerprint(headers) {
   const authorization = Object.entries(headers).find(([key]) => key.toLowerCase() === "authorization")?.[1];
-  return authorization ? createHash6("sha256").update(authorization).digest("hex") : "";
+  return authorization ? createHash5("sha256").update(authorization).digest("hex") : "";
 }
 function bodyToString(body) {
   if (body == null) return "";
@@ -8991,13 +8712,13 @@ function responsesWebSocketPromptFingerprint(payload) {
   delete stable.previous_response_id;
   delete stable.stream;
   delete stable.background;
-  return createHash6("sha256").update(canonicalJson(stable)).digest("hex");
+  return createHash5("sha256").update(canonicalJson(stable)).digest("hex");
 }
 function responsesWebSocketPromptFieldHashes(payload) {
   const hashes = {};
   for (const key of Object.keys(payload).sort()) {
     if (key === "input" || key === "previous_response_id" || key === "stream" || key === "background") continue;
-    hashes[key] = createHash6("sha256").update(canonicalJson(payload[key])).digest("hex").slice(0, 12);
+    hashes[key] = createHash5("sha256").update(canonicalJson(payload[key])).digest("hex").slice(0, 12);
   }
   return hashes;
 }
@@ -9034,7 +8755,7 @@ function responsesWebSocketPartitionKey(wsUrl, payload, options = {}, authorizat
     authorizationFingerprint,
     claudeAgentId
   ].join("");
-  return createHash6("sha256").update(material).digest("hex");
+  return createHash5("sha256").update(material).digest("hex");
 }
 function inputArray(payload) {
   return Array.isArray(payload.input) ? payload.input : [];
@@ -9054,9 +8775,12 @@ function toolSchemaDefaults(payload) {
     if (!properties || typeof properties !== "object") return;
     const perTool = /* @__PURE__ */ new Map();
     for (const [prop, schema] of Object.entries(properties)) {
-      if (schema && typeof schema === "object" && "default" in schema) {
-        perTool.set(prop, canonicalJson(schema.default));
-      }
+      if (!schema || typeof schema !== "object") continue;
+      const rule = {};
+      if ("default" in schema) rule.default = canonicalJson(schema.default);
+      const scalar = schemaScalarKind(schema, parameters);
+      if (scalar) rule.scalar = scalar;
+      if (rule.default !== void 0 || rule.scalar) perTool.set(prop, rule);
     }
     if (perTool.size) defaults.set(record.name, perTool);
   };
@@ -9069,7 +8793,7 @@ function toolSchemaDefaultsFingerprint(defaults) {
     name,
     [...perTool.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
   ]);
-  return createHash6("sha256").update(JSON.stringify(tuples)).digest("hex").slice(0, 16);
+  return createHash5("sha256").update(JSON.stringify(tuples)).digest("hex").slice(0, 16);
 }
 function stripSchemaDefaults(name, args, defaults) {
   if (!defaults) return args;
@@ -9078,9 +8802,10 @@ function stripSchemaDefaults(name, args, defaults) {
   if (!perTool) return args;
   const out = {};
   for (const [key, value] of Object.entries(args)) {
-    const expected = perTool.get(key);
-    if (expected !== void 0 && canonicalJson(value) === expected) continue;
-    out[key] = value;
+    const rule = perTool.get(key);
+    const typed = rule?.scalar ? coerceEchoedScalar(value, rule.scalar) : value;
+    if (rule?.default !== void 0 && canonicalJson(typed) === rule.default) continue;
+    out[key] = typed;
   }
   return out;
 }
@@ -9118,7 +8843,7 @@ function conversationItemKind(value) {
   return "object";
 }
 function conversationItemHash(value, defaults) {
-  return createHash6("sha256").update(canonicalJson(normalizeToolCallJson(value, defaults))).digest("hex").slice(0, 16);
+  return createHash5("sha256").update(canonicalJson(normalizeToolCallJson(value, defaults))).digest("hex").slice(0, 16);
 }
 function reasoningNormalizationGap(expected, actual, defaults) {
   if (conversationItemKind(expected) !== "reasoning" || conversationItemKind(actual) !== "reasoning") return void 0;
@@ -9418,7 +9143,7 @@ function diagnosticTextFingerprint(field, value) {
   if (typeof value !== "string" || value.length === 0) return {};
   return {
     [`${field}Bytes`]: Buffer.byteLength(value),
-    [`${field}Hash`]: createHash6("sha256").update(value).digest("hex").slice(0, 16)
+    [`${field}Hash`]: createHash5("sha256").update(value).digest("hex").slice(0, 16)
   };
 }
 function responseFailureDetails(event) {
@@ -9454,7 +9179,7 @@ function emitResponseErrorDiagnostic(entry, ctx, details) {
   emitContextDiagnostic(entry, ctx, { event: "ws_response_error", ...details });
 }
 function diagnosticItemIdHash(value) {
-  return typeof value === "string" && value.length > 0 ? createHash6("sha256").update(value).digest("hex").slice(0, 16) : void 0;
+  return typeof value === "string" && value.length > 0 ? createHash5("sha256").update(value).digest("hex").slice(0, 16) : void 0;
 }
 function reasoningPartIndex(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
@@ -9969,7 +9694,10 @@ function transportReplaySafe(ctx) {
 }
 function handleSocketMessage(entry, data) {
   const ctx = entry.current;
-  if (!ctx || ctx.closed) return;
+  if (!ctx || ctx.closed) {
+    if (entry.connectionDiagnostic) observeIdleFrame(entry, data);
+    return;
+  }
   const text5 = Array.isArray(data) ? Buffer.concat(data).toString("utf8") : data.toString("utf8");
   ctx.frameCount += 1;
   if (ctx.transportRetryPending) {
@@ -9989,6 +9717,7 @@ function handleSocketMessage(entry, data) {
     return;
   }
   const type = eventType(event);
+  if (isQuotaEvent(type)) observeQuotaEvent(entry, event, "during_response", ctx.emitDiagnostic);
   trackReasoningProtocol(entry, ctx, event, type);
   captureOutput(ctx, event);
   if (type === "response.completed") {
@@ -10180,7 +9909,62 @@ function numericRetryAfterHeader(value) {
   const single = Array.isArray(value) ? value[0] : value;
   return typeof single === "string" && /^\d+$/.test(single.trim()) ? Number(single.trim()) : void 0;
 }
-function createConnection(WebSocket, wsUrl, headers, persistent, key, options, debug, agent) {
+function isQuotaEvent(type) {
+  return type === "codex.rate_limits";
+}
+var QUOTA_LEDGER_MAX_BYTES = 8e3;
+var QUOTA_FIELDS_MAX_COUNT = 24;
+function boundedLedger(value) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    return {};
+  }
+  if (serialized === void 0) return {};
+  const bytes = Buffer.byteLength(serialized);
+  return bytes <= QUOTA_LEDGER_MAX_BYTES ? { value, bytes } : { bytes };
+}
+function observeQuotaEvent(entry, event, phase, emit) {
+  if (!emit) return;
+  const record = event;
+  const rate = boundedLedger(record.rate_limits);
+  const additional = boundedLedger(record.additional_rate_limits);
+  const codeReview = boundedLedger(record.code_review_rate_limits);
+  const credits = boundedLedger(record.credits);
+  const promo = boundedLedger(record.promo);
+  emit({
+    event: "ws_rate_limits",
+    connectionId: entry.debugId,
+    generation: entry.generation,
+    phase,
+    upstreamEventType: "codex.rate_limits",
+    fieldCount: Object.keys(record).length,
+    fieldsPresent: Object.keys(record).slice(0, QUOTA_FIELDS_MAX_COUNT).map(boundedDiagnosticIdentifier).filter((name) => name !== void 0),
+    rateLimits: rate.value,
+    rateLimitsBytes: rate.bytes,
+    additionalRateLimits: additional.value,
+    additionalRateLimitsBytes: additional.bytes,
+    codeReviewRateLimits: codeReview.value,
+    codeReviewRateLimitsBytes: codeReview.bytes,
+    credits: credits.value,
+    creditsBytes: credits.bytes,
+    promo: promo.value,
+    promoBytes: promo.bytes,
+    planType: boundedDiagnosticIdentifier(record.plan_type)
+  });
+}
+function observeIdleFrame(entry, data) {
+  let event;
+  try {
+    event = JSON.parse(Array.isArray(data) ? Buffer.concat(data).toString("utf8") : data.toString("utf8"));
+  } catch {
+    return;
+  }
+  if (!isQuotaEvent(eventType(event))) return;
+  observeQuotaEvent(entry, event, "idle", entry.connectionDiagnostic);
+}
+function createConnection(WebSocket, wsUrl, headers, persistent, key, options, debug, agent, connectionDiagnostic) {
   const now = options.now();
   const socket = new WebSocket(wsUrl, agent ? { headers, agent } : { headers });
   const entry = {
@@ -10195,7 +9979,8 @@ function createConnection(WebSocket, wsUrl, headers, persistent, key, options, d
     lastUsedAt: now,
     inFlight: false,
     options,
-    debug
+    debug,
+    connectionDiagnostic
   };
   if (persistent && key) registerEntry(entry);
   debug(
@@ -10560,7 +10345,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       keyTuple: {
         wsUrl,
         providerId: options.providerId ?? "openai",
-        accountIdHash: options.accountId ? createHash6("sha256").update(options.accountId).digest("hex").slice(0, 16) : "",
+        accountIdHash: options.accountId ? createHash5("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,
@@ -10612,6 +10397,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       })),
       evictions
     }, diagnosticCorrelation);
+    const connectionDiagnostic = options.onDiagnostic ? (event) => emitDiagnostic(options, event, {}) : void 0;
     let activeContext;
     const stream = new ReadableStream({
       start(controller) {
@@ -10644,7 +10430,8 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
             partitionKey,
             resolvedOptions,
             debug,
-            proxyAgent
+            proxyAgent,
+            connectionDiagnostic
           )
         };
         activeContext = ctx;
@@ -10656,7 +10443,8 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
           partitionKey,
           resolvedOptions,
           debug,
-          proxyAgent
+          proxyAgent,
+          connectionDiagnostic
         );
         dispatchContext(entry, ctx);
         const signal = init?.signal;
@@ -10688,7 +10476,7 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
 }
 
 // src/oauth/claude-identity.ts
-import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID3 } from "crypto";
 var CLAUDE_CODE_CLI_VERSION = "2.1.195";
 var CLAUDE_CODE_USER_AGENT = `claude-cli/${CLAUDE_CODE_CLI_VERSION} (external, cli)`;
 var CLAUDE_CODE_ENTRYPOINT = process.env.CLAUDE_CODE_ENTRYPOINT ?? "cli";
@@ -10703,7 +10491,7 @@ function getOrCreateSessionId(seed) {
   return id;
 }
 function uuidFromHash(input) {
-  const h = createHash7("sha256").update(input).digest("hex");
+  const h = createHash6("sha256").update(input).digest("hex");
   return [
     h.slice(0, 8),
     h.slice(8, 12),
@@ -10717,7 +10505,7 @@ var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function resolveCliUserID(providerData, seed) {
   const v = providerData?.cliUserID;
   if (typeof v === "string" && HEX64_RE.test(v)) return v;
-  return createHash7("sha256").update(`cliUserID:${seed}`).digest("hex");
+  return createHash6("sha256").update(`cliUserID:${seed}`).digest("hex");
 }
 function resolveAccountUUID(providerData, seed) {
   const v = providerData?.accountUUID;
@@ -11621,7 +11409,7 @@ function thinkingProviderOptions(npm) {
 
 // src/proxy.ts
 import { createServer } from "http";
-import { appendFileSync as appendFileSync2, openSync as openSync7, writeSync as writeSync5, closeSync as closeSync7 } from "fs";
+import { appendFileSync as appendFileSync2, openSync as openSync7, writeSync as writeSync4, closeSync as closeSync7 } from "fs";
 
 // src/http-utils.ts
 import * as zlib from "zlib";
@@ -12054,7 +11842,7 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/sdk-adapter.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { streamText, generateText, tool, jsonSchema } from "ai";
 
 // src/proxy-shared.ts
@@ -12484,7 +12272,7 @@ function extractClaudeAgentIds(headers) {
   };
 }
 function claudeSessionPromptCacheKey(sessionId) {
-  return "relay-session-" + createHash8("sha256").update(sessionId).digest("hex").slice(0, 32);
+  return "relay-session-" + createHash7("sha256").update(sessionId).digest("hex").slice(0, 32);
 }
 function anthropicEffortFromRequest(body) {
   const effort = body.output_config?.effort;
@@ -12494,7 +12282,7 @@ function anthropicEffortFromRequest(body) {
 function openAiPromptCacheKey(system, tools) {
   const toolSig = (tools ?? []).map((t) => `${t.name}
${t.description ?? ""}
${JSON.stringify(t.input_schema ?? {})}`).join("");
   const material = `${system ?? ""}\0${toolSig}`;
-  return "relay-" + createHash8("sha256").update(material).digest("hex").slice(0, 32);
+  return "relay-" + createHash7("sha256").update(material).digest("hex").slice(0, 32);
 }
 function supportsOpenAiPromptCacheBreakpoints(modelId) {
   const match = modelId.toLowerCase().match(/^gpt-(\d+)(?:\.(\d+))?(?:-|$)/);
@@ -13427,7 +13215,7 @@ function appendSecureLog(logPath, line) {
   try {
     const fd = openSync7(logPath, "a", 384);
     try {
-      writeSync5(fd, `${(/* @__PURE__ */ new Date()).toISOString()} ${redacted}
+      writeSync4(fd, `${(/* @__PURE__ */ new Date()).toISOString()} ${redacted}
 `);
     } finally {
       closeSync7(fd);
@@ -14127,25 +13915,12 @@ function buildHttpProxyRoutes(providers, favorites, modelAliases = void 0, max =
 }
 
 // src/patcher.ts
-function getPatchManifestPath() {
-  return join8(getAppHome(), "patch-state.json");
-}
 function getPatchLockPath() {
-  return join8(getAppHome(), "patch.lock");
-}
-function readPatchManifest(path = getPatchManifestPath()) {
-  try {
-    const parsed = JSON.parse(readFileSync10(path, "utf8"));
-    if (parsed && typeof parsed.binaryPath === "string" && typeof parsed.configHash === "string") {
-      return parsed;
-    }
-  } catch {
-  }
-  return null;
+  return join7(getAppHome(), "patch.lock");
 }
 function writePatchManifest(manifest, path = getPatchManifestPath()) {
   mkdirSync5(getAppHome(), { recursive: true, mode: 448 });
-  writeFileSync6(path, `${JSON.stringify(manifest, null, 2)}
+  writeFileSync5(path, `${JSON.stringify(manifest, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 function buildPatchModelConfig(favorites, aliases, modelMetaFor) {
@@ -14220,7 +13995,7 @@ function computePatchConfigHash(config, transformsVersion = PATCH_TRANSFORMS_VER
   if (localPatchIdentity !== void 0) {
     payload.push(["local-patches", localPatchIdentity]);
   }
-  return createHash9("sha256").update(JSON.stringify(payload)).digest("hex");
+  return createHash8("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 function buildDesiredPatchConfig(options = {}) {
   const prefs = loadPreferences();
@@ -14298,12 +14073,12 @@ function pidIsAlive(pid) {
 function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
   const now = opts.now ?? Date.now();
   const isAlive = opts.isAlive ?? pidIsAlive;
-  mkdirSync5(join8(lockPath, ".."), { recursive: true, mode: 448 });
+  mkdirSync5(join7(lockPath, ".."), { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
       const fd = openSync8(lockPath, "wx");
       const content = { pid: process.pid, startedAt: now };
-      writeFileSync6(fd, JSON.stringify(content));
+      writeFileSync5(fd, JSON.stringify(content));
       closeSync8(fd);
       return () => {
         try {
@@ -14314,7 +14089,7 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
     } catch {
       let stale = false;
       try {
-        const existing = JSON.parse(readFileSync10(lockPath, "utf8"));
+        const existing = JSON.parse(readFileSync9(lockPath, "utf8"));
         stale = !existing.pid || !isAlive(existing.pid) || typeof existing.startedAt === "number" && now - existing.startedAt > PATCH_LOCK_STALE_MS;
       } catch {
         stale = true;
@@ -14336,11 +14111,11 @@ function takeIgnoredLaunchOverride() {
 }
 function resolveClaudeBinaryForPatch() {
   const envOverride = process.env["TWEAKCC_CC_INSTALLATION_PATH"]?.trim() || null;
-  const nativeSymlink = join8(homedir3(), ".local", "bin", "claude");
-  if (envOverride && !existsSync5(envOverride)) {
+  const nativeSymlink = join7(homedir2(), ".local", "bin", "claude");
+  if (envOverride && !existsSync4(envOverride)) {
     return { ok: false, reason: "patch-target-missing", declaredPath: envOverride };
   }
-  const source = envOverride || (existsSync5(nativeSymlink) ? nativeSymlink : null) || findClaudeBinary();
+  const source = envOverride || (existsSync4(nativeSymlink) ? nativeSymlink : null) || findClaudeBinary();
   if (!source) return { ok: false, reason: "binary-not-found" };
   let resolved;
   try {
@@ -14372,7 +14147,7 @@ function resolveClaudeBinaryForPatch() {
   }
   ignoredLaunchOverride = launchOverrideResolved && launchOverrideResolved !== resolved ? { used: resolved, ignored: launchOverride } : null;
   try {
-    if (!statSync8(resolved).isFile()) return { ok: false, reason: "binary-not-found" };
+    if (!statSync7(resolved).isFile()) return { ok: false, reason: "binary-not-found" };
   } catch {
     return { ok: false, reason: "binary-not-found" };
   }
@@ -14433,10 +14208,10 @@ function publishFileByRename(from, to, mode) {
   try {
     copyFileSync(from, temp);
     if (mode !== void 0) chmodSync4(temp, mode);
-    renameSync3(temp, to);
+    renameSync2(temp, to);
   } catch (err) {
     try {
-      rmSync2(temp, { force: true });
+      rmSync(temp, { force: true });
     } catch {
     }
     throw err;
@@ -14504,8 +14279,8 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
   try {
     mkdirSync5(backupDir(), { recursive: true });
     const { tryDetectInstallation, readContent, writeContent } = await import("tweakcc");
-    candidateDir = mkdtempSync(join8(dirname5(binaryPath), ".clodex-patch-"));
-    const candidatePath = join8(candidateDir, basename(binaryPath));
+    candidateDir = mkdtempSync(join7(dirname5(binaryPath), ".clodex-patch-"));
+    const candidatePath = join7(candidateDir, basename(binaryPath));
     const seedCandidate = async (from) => {
       copyFileSync(from, candidatePath);
       const shim = shimEntryModuleName(candidatePath);
@@ -14652,9 +14427,9 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
     }
     if (writeShim) restoreEntryModuleName(candidatePath, writeShim, { resign: true });
     else if (publishedBlob) resignMachOBinary(candidatePath);
-    patchedSize = statSync8(candidatePath).size;
+    patchedSize = statSync7(candidatePath).size;
     patchedSha256 = sha256File(candidatePath);
-    renameSync3(candidatePath, binaryPath);
+    renameSync2(candidatePath, binaryPath);
   } catch (err) {
     const detailLines = err instanceof PatchApplyError ? summarizePatchResults(err.results) : [];
     if (opts.trace && detailLines.length) {
@@ -14669,7 +14444,7 @@ async function applyPatch(binaryPath, version, desired, configHash, opts) {
   } finally {
     if (candidateDir !== void 0) {
       try {
-        rmSync2(candidateDir, { recursive: true, force: true });
+        rmSync(candidateDir, { recursive: true, force: true });
       } catch (err) {
         if (opts.trace) {
           process.stderr.write(
@@ -14743,7 +14518,7 @@ function runRestoreCommand(target) {
   }
   if (manifest && manifest.backupPath && manifest.binaryPath === binaryPath && manifest.claudeVersion !== version && manifest.backupPath !== plan.backupPath) {
     try {
-      if (existsSync5(manifest.backupPath)) {
+      if (existsSync4(manifest.backupPath)) {
         recordBackupProvenance(manifest.backupPath, manifest.binaryPath, {
           assumed: manifest.pristineProvenance === "assumed"
         });
@@ -14772,7 +14547,7 @@ function runRestoreCommand(target) {
   }
   let publishedMode;
   try {
-    publishedMode = statSync8(binaryPath).mode;
+    publishedMode = statSync7(binaryPath).mode;
   } catch {
   }
   try {
@@ -14831,7 +14606,7 @@ async function runPatchCommand(opts = {}) {
     binaryPath,
     claudeVersion: version,
     configHash,
-    binarySize: statSync8(binaryPath).size
+    binarySize: statSync7(binaryPath).size
   });
   if (state === "current") {
     p2.log.success(`claude ${version} is already patched with the current model config \u2014 nothing to do.`);
@@ -14844,7 +14619,7 @@ async function runPatchCommand(opts = {}) {
   }
   if (manifest && manifest.backupPath && (manifest.binaryPath !== binaryPath || manifest.claudeVersion !== version)) {
     try {
-      if (existsSync5(manifest.backupPath)) {
+      if (existsSync4(manifest.backupPath)) {
         recordBackupProvenance(manifest.backupPath, manifest.binaryPath, {
           assumed: manifest.pristineProvenance === "assumed"
         });
@@ -14900,7 +14675,7 @@ async function runLaunchPatchCheck(opts = {}) {
       binaryPath: resolved.binaryPath,
       claudeVersion: resolved.version,
       configHash,
-      binarySize: statSync8(resolved.binaryPath).size
+      binarySize: statSync7(resolved.binaryPath).size
     });
     if (state === "current") return;
     const interactive = !opts.dryRun && !opts.agentStdout && process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -15237,16 +15012,16 @@ function localProvidersToServerModels(localProviders) {
 import { randomUUID as randomUUID5 } from "crypto";
 import {
   closeSync as closeSync9,
-  existsSync as existsSync6,
+  existsSync as existsSync5,
   fstatSync as fstatSync3,
   fsyncSync as fsyncSync2,
   lstatSync,
   mkdirSync as mkdirSync6,
   openSync as openSync9,
-  readFileSync as readFileSync11,
-  renameSync as renameSync4,
+  readFileSync as readFileSync10,
+  renameSync as renameSync3,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync6
 } from "fs";
 import { dirname as dirname6 } from "path";
 var JOURNAL_SCHEMA_VERSION = 1;
@@ -15327,7 +15102,7 @@ function parseJournal(raw) {
   };
 }
 function readJournalUnlocked(path) {
-  if (!existsSync6(path)) return emptyJournal();
+  if (!existsSync5(path)) return emptyJournal();
   let fd;
   try {
     const before = lstatSync(path);
@@ -15350,7 +15125,7 @@ function readJournalUnlocked(path) {
     if (opened.size > MAX_JOURNAL_BYTES) {
       throw new Error("Credential cleanup journal is too large.");
     }
-    return parseJournal(JSON.parse(readFileSync11(fd, "utf8")));
+    return parseJournal(JSON.parse(readFileSync10(fd, "utf8")));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Could not read credential cleanup journal: ${message}`);
@@ -15378,13 +15153,13 @@ function writeJournalUnlocked(journal, path) {
   let fd;
   try {
     fd = openSync9(tmp, "wx", FILE_MODE4);
-    writeFileSync7(fd, `${JSON.stringify(journal, null, 2)}
+    writeFileSync6(fd, `${JSON.stringify(journal, null, 2)}
 `);
     fsyncSync2(fd);
     closeSync9(fd);
     fd = void 0;
     assertRegistryWriteOwnership(path);
-    renameSync4(tmp, path);
+    renameSync3(tmp, path);
     syncParentDirectory(path);
   } finally {
     if (fd !== void 0) closeSync9(fd);
@@ -19363,8 +19138,8 @@ import { createBrotliDecompress, createGunzip, createInflate } from "zlib";
 
 // src/http-proxy/ca.ts
 import { randomBytes as randomBytes2 } from "crypto";
-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 { chmodSync as chmodSync5, existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname7, join as join8, resolve as resolve3 } from "path";
 import forge from "node-forge";
 var CERT_DIR = "http-proxy";
 var CA_CERT_FILE = "clodex-ca.pem";
@@ -19379,22 +19154,22 @@ function serialNumber() {
   return bytes.toString("hex");
 }
 function certPaths() {
-  const dir = join9(getAppHome(), CERT_DIR);
+  const dir = join8(getAppHome(), CERT_DIR);
   return {
     dir,
-    caCert: join9(dir, CA_CERT_FILE),
-    caKey: join9(dir, CA_KEY_FILE),
-    serverCert: join9(dir, SERVER_CERT_FILE),
-    serverKey: join9(dir, SERVER_KEY_FILE),
-    version: join9(dir, CERT_VERSION_FILE)
+    caCert: join8(dir, CA_CERT_FILE),
+    caKey: join8(dir, CA_KEY_FILE),
+    serverCert: join8(dir, SERVER_CERT_FILE),
+    serverKey: join8(dir, SERVER_KEY_FILE),
+    version: join8(dir, CERT_VERSION_FILE)
   };
 }
 function writePrivate(path, value) {
-  writeFileSync8(path, value, { encoding: "utf8", mode: 384 });
+  writeFileSync7(path, value, { encoding: "utf8", mode: 384 });
   chmodSync5(path, 384);
 }
 function writePublic(path, value) {
-  writeFileSync8(path, value, { encoding: "utf8", mode: 420 });
+  writeFileSync7(path, value, { encoding: "utf8", mode: 420 });
   chmodSync5(path, 420);
 }
 function generateCertificates(paths) {
@@ -19439,8 +19214,8 @@ function generateCertificates(paths) {
 }
 function storedCertificatesAreCurrent(paths) {
   try {
-    const ca = forge.pki.certificateFromPem(readFileSync12(paths.caCert, "utf8"));
-    const server = forge.pki.certificateFromPem(readFileSync12(paths.serverCert, "utf8"));
+    const ca = forge.pki.certificateFromPem(readFileSync11(paths.caCert, "utf8"));
+    const server = forge.pki.certificateFromPem(readFileSync11(paths.serverCert, "utf8"));
     const now = Date.now();
     const renewalBuffer = 7 * 24 * 60 * 60 * 1e3;
     return ca.validity.notBefore.getTime() <= now && ca.validity.notAfter.getTime() > now + renewalBuffer && server.validity.notBefore.getTime() <= now && server.validity.notAfter.getTime() > now + renewalBuffer && ca.verify(ca) && ca.verify(server);
@@ -19451,13 +19226,13 @@ function storedCertificatesAreCurrent(paths) {
 function ensureHttpProxyCertificates() {
   const paths = certPaths();
   const required = [paths.caCert, paths.caKey, paths.serverCert, paths.serverKey, paths.version];
-  const current = required.every(existsSync7) && readFileSync12(paths.version, "utf8") === CERT_VERSION && storedCertificatesAreCurrent(paths);
+  const current = required.every(existsSync6) && readFileSync11(paths.version, "utf8") === CERT_VERSION && storedCertificatesAreCurrent(paths);
   if (!current) generateCertificates(paths);
   return {
     caCertPath: paths.caCert,
-    caCert: readFileSync12(paths.caCert, "utf8"),
-    serverCert: readFileSync12(paths.serverCert, "utf8"),
-    serverKey: readFileSync12(paths.serverKey, "utf8")
+    caCert: readFileSync11(paths.caCert, "utf8"),
+    serverCert: readFileSync11(paths.serverCert, "utf8"),
+    serverKey: readFileSync11(paths.serverKey, "utf8")
   };
 }
 function ensureHttpProxyCaBundle(relayCaCertPath, additionalCaCertPath, onWarning) {
@@ -19471,7 +19246,7 @@ function ensureHttpProxyCaBundle(relayCaCertPath, additionalCaCertPath, onWarnin
   let additionalCa;
   try {
     if (resolve3(additionalCaCertPath) === resolve3(relayCaCertPath)) return relayCaCertPath;
-    additionalCa = readFileSync12(additionalCaCertPath, "utf8").trim();
+    additionalCa = readFileSync11(additionalCaCertPath, "utf8").trim();
   } catch (err) {
     return warn(
       `NODE_EXTRA_CA_CERTS=${additionalCaCertPath} cannot be read (${err instanceof Error ? err.message : String(err)}), so it is not part of the proxy CA bundle. Where node reports this itself it says only "Ignoring extra certs ... load failed", without naming the variable. Clear or correct it.`
@@ -19481,8 +19256,8 @@ function ensureHttpProxyCaBundle(relayCaCertPath, additionalCaCertPath, onWarnin
     return warn(`NODE_EXTRA_CA_CERTS=${additionalCaCertPath} is empty, so it adds nothing.`);
   }
   try {
-    const relayCa = readFileSync12(relayCaCertPath, "utf8").trimEnd();
-    const combinedPath = join9(dirname7(relayCaCertPath), "combined-ca.pem");
+    const relayCa = readFileSync11(relayCaCertPath, "utf8").trimEnd();
+    const combinedPath = join8(dirname7(relayCaCertPath), "combined-ca.pem");
     writePublic(combinedPath, `${relayCa}
 ${additionalCa}
 `);
@@ -20622,6 +20397,7 @@ async function runHttpProxyServerCommand(debug = false, webSocketDiagnostics = f
   if (handle.webSocketDiagnosticsLogPath) {
     console.log(`  WebSocket diagnostics: ${handle.webSocketDiagnosticsLogPath}`);
     console.log(pc10.yellow("  Diagnostic mode records request headers and metadata; credential headers are redacted."));
+    console.log(pc10.yellow("  It also records OpenAI usage-limit reports verbatim, including account credits and promotions."));
   }
   console.log("");
   printHttpProxyModels(loaded.routes, loaded.aliases);
@@ -21001,6 +20777,7 @@ async function runServerCommand(options = {}) {
   if (webSocketDiagnosticsLogPath) {
     console.log(`  WebSocket diagnostics: ${webSocketDiagnosticsLogPath}`);
     console.log(pc11.yellow("  Diagnostic mode records request headers and metadata; credential headers are redacted."));
+    console.log(pc11.yellow("  It also records OpenAI usage-limit reports verbatim, including account credits and promotions."));
   }
   if (mode === "network") {
     for (const { name, address } of getLocalIps()) {
@@ -21290,6 +21067,227 @@ function planLaunchWizard(opts) {
   return { skip: false, target: null };
 }
 
+// src/vscode-launcher.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync2, readdirSync, readFileSync as readFileSync12, rmSync as rmSync2, statSync as statSync8, writeFileSync as writeFileSync8 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname8, join as join9 } from "path";
+import { fileURLToPath } from "url";
+var LAUNCHER_EXE_NAME = "clodex-claude.exe";
+var VSCODE_WRAPPER_SETTING = "claudeCode.claudeProcessWrapper";
+var NODE_PATH_PLACEHOLDER = '"__CLODEX_NODE_PATH__"';
+var WRAPPER_PATH_PLACEHOLDER = '"__CLODEX_WRAPPER_SCRIPT_PATH__"';
+var LAUNCHER_SOURCE_FILE = "clodex-claude-launcher.cs";
+var UTF8_BOM = "\uFEFF";
+var CSC_ARGS = ["/nologo", "/target:exe", "/platform:anycpu", "/optimize+", `/out:${LAUNCHER_EXE_NAME}`, LAUNCHER_SOURCE_FILE];
+var packageRoot = join9(dirname8(fileURLToPath(import.meta.url)), "..");
+function defaultLauncherInputs() {
+  return {
+    launcherSourcePath: join9(packageRoot, "launcher", LAUNCHER_SOURCE_FILE),
+    wrapperScriptPath: join9(packageRoot, "dist", "claude-wrapper.js")
+  };
+}
+function launcherInstallPath(env = process.env) {
+  return join9(getAppHome(env), "bin", LAUNCHER_EXE_NAME);
+}
+function csharpStringLiteral(value) {
+  let literal = '"';
+  for (let i = 0; i < value.length; i += 1) {
+    const unit = value.charCodeAt(i);
+    if (unit === 92) literal += "\\\\";
+    else if (unit === 34) literal += '\\"';
+    else if (unit >= 32 && unit <= 126) literal += value[i];
+    else literal += `\\u${unit.toString(16).padStart(4, "0")}`;
+  }
+  return `${literal}"`;
+}
+function renderLauncherSource(template, paths) {
+  const replaceOnce = (source, placeholder, value) => {
+    const first = source.indexOf(placeholder);
+    if (first === -1 || source.indexOf(placeholder, first + 1) !== -1) {
+      throw new Error(`launcher source must contain ${placeholder} exactly once`);
+    }
+    return source.slice(0, first) + csharpStringLiteral(value) + source.slice(first + placeholder.length);
+  };
+  const withNode = replaceOnce(template, NODE_PATH_PLACEHOLDER, paths.nodePath);
+  return replaceOnce(withNode, WRAPPER_PATH_PLACEHOLDER, paths.wrapperScriptPath);
+}
+function cscSearchRoots(env = process.env) {
+  const windir = env.WINDIR?.trim() || env.SystemRoot?.trim() || "C:\\Windows";
+  const dotnet = join9(windir, "Microsoft.NET");
+  return [join9(dotnet, "Framework64"), join9(dotnet, "Framework")];
+}
+function frameworkVersionKey(name) {
+  return name.slice(1).split(".").map((part) => Number.parseInt(part, 10) || 0);
+}
+function compareVersionKeys(a, b) {
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const diff = (a[i] ?? 0) - (b[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function findCsc(env = process.env) {
+  for (const root of cscSearchRoots(env)) {
+    let entries;
+    try {
+      entries = readdirSync(root);
+    } catch {
+      continue;
+    }
+    const candidates = entries.filter((name) => /^v4\.\d+(\.\d+)*$/i.test(name)).sort((a, b) => compareVersionKeys(frameworkVersionKey(b), frameworkVersionKey(a)));
+    for (const version of candidates) {
+      const csc = join9(root, version, "csc.exe");
+      try {
+        if (statSync8(csc).isFile()) return csc;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function formatWrapperSetting(exePath) {
+  return `"${VSCODE_WRAPPER_SETTING}": ${JSON.stringify(exePath)}`;
+}
+var runCsc = (cscPath, args, cwd) => {
+  const result = spawnSync2(cscPath, [...args], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    ...result.error ? { error: result.error } : {}
+  };
+};
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function installVscodeLauncher(opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const env = opts.env ?? process.env;
+  const defaults = defaultLauncherInputs();
+  const nodePath = opts.nodePath ?? process.execPath;
+  const wrapperScriptPath = opts.wrapperScriptPath ?? defaults.wrapperScriptPath;
+  const launcherSourcePath = opts.launcherSourcePath ?? defaults.launcherSourcePath;
+  const compile = opts.compile ?? runCsc;
+  if (platform !== "win32") {
+    return {
+      ok: false,
+      reason: "not-windows",
+      message: `clodex install-vscode-launcher is only needed on Windows. On macOS and Linux npm installs clodex-claude as a program the VS Code extension can spawn directly: set ${VSCODE_WRAPPER_SETTING} to the path printed by \`which clodex-claude\`.`
+    };
+  }
+  const cscPath = findCsc(env);
+  if (!cscPath) {
+    return {
+      ok: false,
+      reason: "no-csc",
+      message: `could not find the .NET Framework C# compiler (csc.exe). It ships with Windows 10/11 under ${cscSearchRoots(env).join(" or ")}\\v4.*; if it is missing, install .NET Framework 4.8 from Microsoft and re-run.`
+    };
+  }
+  for (const [label, path] of [["claude-wrapper.js", wrapperScriptPath], ["node.exe", nodePath], ["launcher source", launcherSourcePath]]) {
+    if (!existsSync7(path)) {
+      return { ok: false, reason: "missing-input", message: `${label} is not at ${path}; reinstall clodex and re-run.` };
+    }
+  }
+  let source;
+  try {
+    source = renderLauncherSource(readFileSync12(launcherSourcePath, "utf8"), { nodePath, wrapperScriptPath });
+  } catch (err) {
+    return { ok: false, reason: "missing-input", message: `could not prepare the launcher source: ${describeError(err)}` };
+  }
+  const exePath = launcherInstallPath(env);
+  const tempRoot = opts.tempRoot ?? tmpdir();
+  let scratch;
+  try {
+    scratch = mkdtempSync2(join9(tempRoot, "clodex-vscode-launcher-"));
+  } catch (err) {
+    return { ok: false, reason: "install-failed", message: `could not create a scratch directory under ${tempRoot}: ${describeError(err)}` };
+  }
+  let result;
+  try {
+    result = buildAndPublish({ scratch, source, cscPath, compile, exePath, nodePath, wrapperScriptPath });
+  } catch (err) {
+    result = { ok: false, reason: "install-failed", message: `could not build the launcher: ${describeError(err)}` };
+  }
+  const cleanupWarning = removeScratch(scratch);
+  return cleanupWarning ? { ...result, warning: cleanupWarning } : result;
+}
+function buildAndPublish(step) {
+  const { scratch, cscPath, exePath } = step;
+  writeFileSync8(join9(scratch, LAUNCHER_SOURCE_FILE), UTF8_BOM + step.source, "utf8");
+  const compiled = step.compile(cscPath, CSC_ARGS, scratch);
+  const builtExe = join9(scratch, LAUNCHER_EXE_NAME);
+  if (compiled.error || compiled.status !== 0 || !existsSync7(builtExe)) {
+    const output = [compiled.stdout, compiled.stderr].map((text5) => text5.trim()).filter(Boolean).join("\n");
+    return {
+      ok: false,
+      reason: "compile-failed",
+      message: compiled.error ? `could not run ${cscPath}: ${compiled.error.message}` : `${cscPath} failed (exit ${compiled.status ?? "signal"}) while building the launcher.`,
+      ...output ? { detail: output } : {}
+    };
+  }
+  try {
+    mkdirSync8(dirname8(exePath), { recursive: true });
+    publishFileByRename(builtExe, exePath);
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "install-failed",
+      message: `could not write ${exePath}: ${describeError(err)}. If VS Code is running a chat through the launcher, close it and re-run.`
+    };
+  }
+  return { ok: true, exePath, cscPath, nodePath: step.nodePath, wrapperScriptPath: step.wrapperScriptPath };
+}
+function removeScratch(scratch) {
+  try {
+    rmSync2(scratch, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    return void 0;
+  } catch (err) {
+    return `could not remove the scratch directory ${scratch}: ${describeError(err)}`;
+  }
+}
+function successReport(result) {
+  return [
+    `Built ${result.exePath}`,
+    `  compiler: ${result.cscPath}`,
+    `  runs:     ${result.nodePath} ${result.wrapperScriptPath}`,
+    "",
+    "Add this to your VS Code settings (Ctrl+Shift+P \u2192 Preferences: Open User Settings (JSON)):",
+    "",
+    `  ${formatWrapperSetting(result.exePath)}`,
+    "",
+    "Then reload the window (Developer: Reload Window). Keep `clodex server --proxy` running:",
+    "the launcher starts clodex-claude, which finds that server and bridges each session to it,",
+    "so HTTPS_PROXY/HTTP_PROXY/NODE_EXTRA_CA_CERTS entries in claudeCode.environmentVariables",
+    "are no longer needed (remove them so Claude still starts when the server is down).",
+    "",
+    "With `clodex patch` applied to your installed Claude Code, clodex-claude runs that patched",
+    "install in place of the extension's bundled claude.exe when the two builds match, which is",
+    "what puts clodex models in the extension's model picker. Re-run `clodex patch` after either",
+    "the extension or the CLI updates; a mismatched chat runs the bundled binary and logs one line",
+    `to the extension's "Claude VSCode" output channel.`,
+    "",
+    "Re-run `clodex install-vscode-launcher` after switching Node versions or moving the clodex",
+    "install: the paths above are compiled into the executable."
+  ];
+}
+function runInstallVscodeLauncherCommand(opts = {}) {
+  const result = installVscodeLauncher(opts);
+  if (result.warning) console.error(`clodex: warning: ${result.warning}`);
+  if (!result.ok) {
+    console.error(`clodex: ${result.message}`);
+    if (result.detail) console.error(result.detail);
+    return 1;
+  }
+  console.log(successReport(result).join("\n"));
+  return 0;
+}
+
 // src/cli.ts
 var STARTER_CLAUDE_FLAGS = /* @__PURE__ */ new Set(["--dry-run", "--trace", "--fast", "--endpoint", "--proxy", "--save-mode", "--help", "-h", "--version", "-v"]);
 var CLODEX_LAUNCH_FLAGS = /* @__PURE__ */ new Set(["--provider", "--model", "--context"]);
@@ -21511,6 +21509,15 @@ function parseArgs(args) {
     }
     return parsed2;
   }
+  if (first === "install-vscode-launcher") {
+    const parsed2 = emptyParsed("install-vscode-launcher");
+    for (const arg of rest) {
+      if (arg === "--help" || arg === "-h") parsed2.showHelp = true;
+      else if (arg === "--version" || arg === "-v") parsed2.showVersion = true;
+      else if (!parsed2.error) parsed2.error = `Unknown install-vscode-launcher option: ${arg}`;
+    }
+    return parsed2;
+  }
   if (first !== "claude") {
     return {
       ...emptyParsed("root"),
@@ -21556,6 +21563,7 @@ ${pc13.bold("Usage:")}
   clodex models
   clodex favorites
   clodex providers
+  clodex install-vscode-launcher
   clodex --help
   clodex --version
 
@@ -21570,6 +21578,9 @@ ${pc13.bold("Commands:")}
   models      Manage favorite models and aliases (max ${MAX_MODEL_CATALOG})
   favorites   Alias for models
   providers   Add or sign in to model providers
+  install-vscode-launcher
+              Windows only: build the .exe the Claude Code VS Code extension
+              needs to launch Claude through clodex
 
 ${pc13.bold("Bridge modes (claude and server):")}
   --endpoint   Local Anthropic-format gateway; Claude Code launches with
@@ -21676,8 +21687,9 @@ ${pc13.bold("Common options (both modes):")}
                                ~/.clodex/server-runtime.json, so the
                                clodex-claude wrapper never bridges to it
                                (CLODEX_NO_DISCOVERY=1 works too)
-  --ws-diagnostics             Log sanitized request envelopes and WebSocket
-                               head decisions
+  --ws-diagnostics             Log sanitized request envelopes, WebSocket
+                               head decisions, and the server's usage-limit
+                               reports verbatim (includes account credits)
   --help, --version            Help / version
 
 ${pc13.bold("Endpoint mode only")} ${pc13.dim("(error if combined with --proxy)")}:
@@ -21810,6 +21822,42 @@ ${pc13.bold("Behavior:")}
   permissions. Local failures are reported but never block the built-ins.
   Run clodex patch again after every claude update.`;
 }
+function installVscodeLauncherHelpText() {
+  return `${pc13.bold("clodex install-vscode-launcher")} v${VERSION}
+Windows only. Build a small native clodex-claude.exe that the Claude Code VS Code
+extension can use as its claudeCode.claudeProcessWrapper, so chats in the editor
+launch Claude Code through clodex.
+
+${pc13.bold("Usage:")}
+  clodex install-vscode-launcher
+  clodex install-vscode-launcher --help
+
+${pc13.bold("Behavior:")}
+  The extension spawns its process wrapper without a shell, and on Windows npm
+  installs clodex-claude as script shims (clodex-claude, .cmd, .ps1) with no .exe,
+  so the setting fails with spawn EINVAL.
+  This command compiles launcher/clodex-claude-launcher.cs from the clodex package
+  with the C# compiler that ships inside the .NET Framework on Windows 10/11
+  (csc.exe under %WINDIR%\\Microsoft.NET), writes the result to
+  ~/.clodex/bin/clodex-claude.exe, and prints the VS Code setting to paste.
+  Nothing is downloaded and no settings file is edited.
+
+  The launcher runs node.exe with clodex's claude-wrapper.js and hands the
+  extension's arguments through unchanged, so the wrapper bridges the session to
+  a running clodex server --proxy. Node and Claude Code are tied to the launcher
+  with a Windows job object so that cancelling a chat leaves no stray processes;
+  if Windows refuses the job object the launcher says so on stderr and runs anyway.
+  As on macOS and Linux, clodex-claude then runs your clodex-patched install in
+  place of the bundled claude.exe when the two builds match, so clodex models
+  appear in the extension's model picker; re-run clodex patch after updates.
+
+  The paths to node.exe and to the clodex install are compiled in: re-run this
+  command after switching Node versions or moving the clodex install.
+  On macOS and Linux it is not needed \u2014 point the setting at clodex-claude itself.
+
+${pc13.bold("Setup guide:")}
+  docs/windows-setup.md in the clodex package (also on GitHub).`;
+}
 function printHelp(text5) {
   console.log(`
 ${text5}
@@ -22719,6 +22767,17 @@ Error: ${resolved.error}
       localPatches: parsed.patchLocalPatches
     });
   }
+  if (parsed.command === "install-vscode-launcher") {
+    if (parsed.showVersion) {
+      console.log(VERSION);
+      return 0;
+    }
+    if (parsed.showHelp) {
+      printHelp(installVscodeLauncherHelpText());
+      return 0;
+    }
+    return runInstallVscodeLauncherCommand();
+  }
   if (parsed.showVersion) {
     console.log(VERSION);
     return 0;
@@ -22741,7 +22800,7 @@ Error: ${resolved.error}
 function isCliEntryPoint() {
   if (!process.argv[1]) return false;
   try {
-    return realpathSync3(fileURLToPath(import.meta.url)) === realpathSync3(process.argv[1]);
+    return realpathSync3(fileURLToPath2(import.meta.url)) === realpathSync3(process.argv[1]);
   } catch {
     return false;
   }
@@ -22759,6 +22818,7 @@ if (isCliEntryPoint()) {
 }
 export {
   claudeHelpText,
+  installVscodeLauncherHelpText,
   main,
   modelsHelpText,
   parseArgs,