codexuse-cli 6.2.12 → 6.3.0

package/dist/index.js

@@ -2046,7 +2046,7 @@ var require_toml = __commonJS({
 
 // src/commands/accountPool.ts
 var import_node_crypto16 = require("crypto");
-var import_node_path15 = __toESM(require("path"));
+var import_node_path16 = __toESM(require("path"));
 
 // ../../packages/contracts/src/settings/types.ts
 var DEFAULT_ACCOUNT_POOL_EXPOSED_MODELS = [
@@ -3483,11 +3483,23 @@ function resolveDefaultUserDataDir() {
   if (configured && import_node_path4.default.isAbsolute(configured)) {
     return import_node_path4.default.resolve(configured);
   }
-  const home = process.env.HOME || import_node_os.default.homedir();
+  const home = process.env.HOME || process.env.USERPROFILE || import_node_os.default.homedir();
   if (!home) {
     throw new Error("Unable to resolve home directory for app state.");
   }
-  return import_node_path4.default.join(home, "Library", "Application Support", APP_NAME);
+  if (process.platform === "darwin") {
+    return import_node_path4.default.join(home, "Library", "Application Support", APP_NAME);
+  }
+  if (process.platform === "win32") {
+    return import_node_path4.default.join(
+      process.env.APPDATA || import_node_path4.default.join(home, "AppData", "Roaming"),
+      APP_NAME
+    );
+  }
+  return import_node_path4.default.join(
+    process.env.XDG_CONFIG_HOME || import_node_path4.default.join(home, ".config"),
+    APP_NAME
+  );
 }
 function getUserDataDir() {
   return configuredUserDataDir ?? resolveDefaultUserDataDir();
@@ -5662,6 +5674,30 @@ async function readLinuxMachineId() {
   }
   return null;
 }
+function parseWindowsMachineGuid(output) {
+  const match7 = output.match(/^\s*MachineGuid\s+REG_\w+\s+(.+?)\s*$/im);
+  return normalize(match7?.[1]) || null;
+}
+async function readWindowsMachineGuid() {
+  if (process.platform !== "win32") {
+    return null;
+  }
+  try {
+    const { stdout } = await execFileAsync(
+      "reg.exe",
+      [
+        "query",
+        "HKLM\\SOFTWARE\\Microsoft\\Cryptography",
+        "/v",
+        "MachineGuid"
+      ],
+      { timeout: 4e3, windowsHide: true }
+    );
+    return parseWindowsMachineGuid(stdout);
+  } catch {
+    return null;
+  }
+}
 function hashDeviceComponent(value3) {
   return import_node_crypto4.default.createHash("sha256").update(`codexuse-device:${value3}`).digest("hex");
 }
@@ -5671,7 +5707,7 @@ async function getDeviceId() {
   }
   const dbPath = resolveAppStorageDbPath(getUserDataDir());
   const cached2 = normalize(await readDocument(dbPath, DEVICE_ID_DOCUMENT, normalize));
-  const stableDeviceSource = await readHardwareUuid() ?? await readLinuxMachineId();
+  const stableDeviceSource = await readHardwareUuid() ?? await readLinuxMachineId() ?? await readWindowsMachineGuid();
   if (stableDeviceSource) {
     const deviceId2 = hashDeviceComponent(stableDeviceSource);
     if (cached2 !== deviceId2) {
@@ -6631,7 +6667,7 @@ function shouldEnforceProfileLimit(status) {
 // ../../packages/runtime-profiles/src/profiles/profile-manager.ts
 var import_node_crypto15 = require("crypto");
 var import_fs = require("fs");
-var import_node_os5 = __toESM(require("os"), 1);
+var import_node_os8 = __toESM(require("os"), 1);
 var import_path = __toESM(require("path"), 1);
 var import_path2 = require("path");
 var import_toml2 = __toESM(require_toml(), 1);
@@ -6690,29 +6726,68 @@ function resolveProfileIdentityKeyFromProfile(profile) {
 var import_node_child_process5 = require("child_process");
 var import_node_crypto11 = require("crypto");
 var import_node_readline = __toESM(require("readline"), 1);
-var import_node_fs6 = require("fs");
-var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
+var import_node_os6 = __toESM(require("os"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/cli.ts
 var import_node_child_process2 = require("child_process");
+var import_node_fs5 = require("fs");
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+
+// ../../packages/runtime-codex/src/codex/pathCommand.ts
 var import_node_fs4 = require("fs");
 var import_node_path5 = __toESM(require("path"), 1);
+function isRunnableFile(candidate, platform) {
+  try {
+    if (!(0, import_node_fs4.statSync)(candidate).isFile()) return false;
+    (0, import_node_fs4.accessSync)(candidate, platform === "win32" ? import_node_fs4.constants.F_OK : import_node_fs4.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveNpmShimEntrypoint(command, shimPath) {
+  if (!/\.(?:cmd|bat)$/i.test(shimPath)) return null;
+  const root = import_node_path5.default.dirname(shimPath);
+  const candidates = command.toLowerCase() === "codex" ? [import_node_path5.default.join(root, "node_modules", "@openai", "codex", "bin", "codex.js")] : command.toLowerCase() === "codexuse" ? [
+    import_node_path5.default.join(root, "node_modules", "codexuse-cli", "dist", "index.js"),
+    import_node_path5.default.join(root, "node_modules", "@codexuse", "cli", "dist", "index.js")
+  ] : [];
+  return candidates.find((candidate) => isRunnableFile(candidate, "win32")) ?? null;
+}
+function resolveCommandOnPath(command, env = process.env, platform = process.platform) {
+  const direct = import_node_path5.default.isAbsolute(command) || command.includes("/") || command.includes("\\");
+  const extensions = platform === "win32" && import_node_path5.default.extname(command) === "" ? (env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  const directories = direct ? [""] : (env.PATH ?? "").split(platform === "win32" ? ";" : ":").map((entry) => entry.trim().replace(/^"+|"+$/g, "")).filter(Boolean);
+  for (const directory of directories) {
+    for (const extension of extensions) {
+      const candidate = direct ? `${command}${extension}` : import_node_path5.default.join(directory, `${command}${extension}`);
+      if (isRunnableFile(candidate, platform)) {
+        return resolveNpmShimEntrypoint(command, candidate) ?? import_node_path5.default.resolve(candidate);
+      }
+    }
+  }
+  return null;
+}
+
+// ../../packages/runtime-codex/src/codex/cli.ts
 var STABLE_CHANNEL = "stable";
 var ENV_HINTS = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
 var cachedStatus = null;
 var cachedVersion = null;
 function getPathHintEntries() {
-  const homeDir = process.env.HOME ?? "";
+  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? import_node_os2.default.homedir();
   const homeEntries = homeDir ? [
-    import_node_path5.default.join(homeDir, ".local", "bin"),
-    import_node_path5.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
-    import_node_path5.default.join(homeDir, ".fnm", "current", "bin"),
-    import_node_path5.default.join(homeDir, ".volta", "bin"),
-    import_node_path5.default.join(homeDir, ".asdf", "shims"),
-    import_node_path5.default.join(homeDir, ".bun", "bin")
+    import_node_path6.default.join(homeDir, ".local", "bin"),
+    import_node_path6.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
+    import_node_path6.default.join(homeDir, ".fnm", "current", "bin"),
+    import_node_path6.default.join(homeDir, ".volta", "bin"),
+    import_node_path6.default.join(homeDir, ".asdf", "shims"),
+    import_node_path6.default.join(homeDir, ".bun", "bin")
   ] : [];
-  const configuredHints = (process.env.CODEX_PATH_HINTS ?? "").split(import_node_path5.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const configuredHints = (process.env.CODEX_PATH_HINTS ?? "").split(import_node_path6.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
   return [
     "/opt/homebrew/bin",
     "/usr/local/bin",
@@ -6724,9 +6799,9 @@ function fileExists(candidate) {
   if (!candidate) {
     return null;
   }
-  const normalized = import_node_path5.default.resolve(candidate);
+  const normalized = import_node_path6.default.resolve(candidate);
   try {
-    const stats = (0, import_node_fs4.statSync)(normalized);
+    const stats = (0, import_node_fs5.statSync)(normalized);
     if (stats.isFile()) {
       return normalized;
     }
@@ -6753,17 +6828,14 @@ function resolveCodexFromPath() {
     new Set(
       [
         ...getPathHintEntries(),
-        ...pathValue.split(import_node_path5.default.delimiter).map((entry) => entry.trim()).filter(Boolean)
+        ...pathValue.split(import_node_path6.default.delimiter).map((entry) => entry.trim()).filter(Boolean)
       ].filter(Boolean)
     )
   );
-  for (const entry of entries3) {
-    const candidate = fileExists(import_node_path5.default.join(entry, "codex"));
-    if (candidate) {
-      return candidate;
-    }
-  }
-  return null;
+  return resolveCommandOnPath("codex", {
+    ...process.env,
+    PATH: entries3.join(import_node_path6.default.delimiter)
+  });
 }
 function buildUnavailableStatus(reason) {
   return {
@@ -6873,7 +6945,8 @@ async function requireCodexCli() {
 
 // ../../packages/runtime-codex/src/codex/command.ts
 var import_node_child_process3 = require("child_process");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var cachedNodeRuntime = null;
 function isJavaScriptEntrypoint(binaryPath) {
   const normalized = binaryPath.trim().toLowerCase();
@@ -6888,20 +6961,21 @@ function resolveNodeRuntime(env) {
     return cachedNodeRuntime;
   }
   const runtimeEnv = { ...process.env, ...env };
-  const homeDir = runtimeEnv.HOME ?? "";
-  const pathHints = (runtimeEnv.CODEX_PATH_HINTS ?? process.env.CODEX_PATH_HINTS ?? "").split(import_node_path6.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const homeDir = runtimeEnv.HOME ?? runtimeEnv.USERPROFILE ?? import_node_os3.default.homedir();
+  const pathHints = (runtimeEnv.CODEX_PATH_HINTS ?? process.env.CODEX_PATH_HINTS ?? "").split(import_node_path7.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
   const extraPathEntries = [
     "/usr/local/bin",
     "/opt/homebrew/bin",
-    import_node_path6.default.join(homeDir, ".local", "bin"),
-    import_node_path6.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
-    import_node_path6.default.join(homeDir, ".fnm", "current", "bin"),
+    import_node_path7.default.join(homeDir, ".local", "bin"),
+    import_node_path7.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
+    import_node_path7.default.join(homeDir, ".fnm", "current", "bin"),
+    import_node_path7.default.join(homeDir, ".bun", "bin"),
     ...pathHints
   ].filter(Boolean);
   const currentPath = runtimeEnv.PATH ?? "";
   runtimeEnv.PATH = Array.from(
-    /* @__PURE__ */ new Set([...extraPathEntries, ...currentPath.split(import_node_path6.default.delimiter).filter(Boolean)])
-  ).join(import_node_path6.default.delimiter);
+    /* @__PURE__ */ new Set([...extraPathEntries, ...currentPath.split(import_node_path7.default.delimiter).filter(Boolean)])
+  ).join(import_node_path7.default.delimiter);
   const candidates = Array.from(
     new Set(
       [
@@ -6941,19 +7015,19 @@ function buildCodexCommand(binaryPath, args2, env) {
 
 // ../../packages/runtime-codex/src/codex/home.ts
 var import_node_crypto9 = require("crypto");
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 var import_promises2 = require("fs/promises");
-var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_os4 = __toESM(require("os"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 function resolveHomeDir() {
-  return process.env.HOME || import_node_os2.default.homedir();
+  return process.env.HOME || import_node_os4.default.homedir();
 }
 function expandHomePrefix(input, homeDir) {
   if (input === "~") {
     return homeDir;
   }
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return import_node_path7.default.join(homeDir, input.slice(2));
+    return import_node_path8.default.join(homeDir, input.slice(2));
   }
   return input;
 }
@@ -6969,25 +7043,25 @@ function normalizeCodexHomePath(input) {
   if (!configured) {
     return null;
   }
-  return import_node_path7.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
+  return import_node_path8.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
 }
 function resolveDefaultCodexHomeDir() {
-  return normalizeCodexHomePath(process.env.CODEX_HOME) ?? import_node_path7.default.join(resolveHomeDir(), ".codex");
+  return normalizeCodexHomePath(process.env.CODEX_HOME) ?? import_node_path8.default.join(resolveHomeDir(), ".codex");
 }
 function resolveCodexSqliteHomeDir(codexHomePath) {
   return normalizeCodexHomePath(process.env.CODEX_SQLITE_HOME) ?? resolveCodexHomeDir({ codexHomePath });
 }
 function resolveCurrentProfileCodexHomeDir(profileHomeId) {
-  return import_node_path7.default.join(
+  return import_node_path8.default.join(
     resolveProfileCodexHomesRoot(),
     (0, import_node_crypto9.createHash)("sha256").update(profileHomeId).digest("hex").slice(0, 20)
   );
 }
 function resolveProfileCodexHomeDir(profileHomeId) {
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const legacy = import_node_path7.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
-  const currentExists = (0, import_node_fs5.existsSync)(current);
-  const legacyExists = (0, import_node_fs5.existsSync)(legacy);
+  const legacy = import_node_path8.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  const currentExists = (0, import_node_fs6.existsSync)(current);
+  const legacyExists = (0, import_node_fs6.existsSync)(legacy);
   if (currentExists && legacyExists) {
     return current;
   }
@@ -6995,15 +7069,15 @@ function resolveProfileCodexHomeDir(profileHomeId) {
 }
 function findProfileCodexHomeLocationConflict(profileHomeId) {
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const legacy = import_node_path7.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
-  return (0, import_node_fs5.existsSync)(current) && (0, import_node_fs5.existsSync)(legacy) ? { current, legacy } : null;
+  const legacy = import_node_path8.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  return (0, import_node_fs6.existsSync)(current) && (0, import_node_fs6.existsSync)(legacy) ? { current, legacy } : null;
 }
 function resolveProfileCodexHomesRoot() {
-  return import_node_path7.default.join(resolveHomeDir(), ".codexuse", "p");
+  return import_node_path8.default.join(resolveHomeDir(), ".codexuse", "p");
 }
 async function ensureProfileCodexHomesRoot() {
   const root = resolveProfileCodexHomesRoot();
-  const parent = import_node_path7.default.dirname(root);
+  const parent = import_node_path8.default.dirname(root);
   await (0, import_promises2.mkdir)(parent, { recursive: true, mode: 448 });
   await (0, import_promises2.mkdir)(root, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
@@ -7013,13 +7087,13 @@ async function ensureProfileCodexHomesRoot() {
   return root;
 }
 function resolveLegacyProfileCodexHomesRoot() {
-  return import_node_path7.default.join(getUserDataDir(), "profile-homes");
+  return import_node_path8.default.join(getUserDataDir(), "profile-homes");
 }
 async function migrateProfileCodexHomeDir(profileHomeId) {
-  const legacy = import_node_path7.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  const legacy = import_node_path8.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const currentExists = (0, import_node_fs5.existsSync)(current);
-  const legacyExists = (0, import_node_fs5.existsSync)(legacy);
+  const currentExists = (0, import_node_fs6.existsSync)(current);
+  const legacyExists = (0, import_node_fs6.existsSync)(legacy);
   if (currentExists && legacyExists) {
     return current;
   }
@@ -7070,6 +7144,7 @@ async function resolveCodexRuntimeContext(options) {
 }
 
 // ../../packages/runtime-codex/src/cli/env.ts
+var import_node_os5 = __toESM(require("os"), 1);
 function buildCodexChildEnv(overrides = {}) {
   const env = { ...process.env };
   for (const key of Object.keys(env)) {
@@ -7095,7 +7170,7 @@ var import_toml = __toESM(require_toml(), 1);
 // ../../packages/runtime-codex/src/codex/config-metadata.ts
 var import_node_child_process4 = require("child_process");
 var import_promises3 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/openai/codex/main/codex-rs/core/config.schema.json";
 var METADATA_CACHE_TTL_MS = 6e4;
 var FALLBACK_SCHEMA_TOP_LEVEL_KEYS = [
@@ -7281,8 +7356,8 @@ function parseSchemaKeys(schemaRaw) {
 async function readSchemaFromLocal() {
   const candidates = [
     process.env.CODEX_CONFIG_SCHEMA_PATH,
-    import_node_path8.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
-    import_node_path8.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
+    import_node_path9.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
+    import_node_path9.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
     try {
@@ -7388,7 +7463,7 @@ async function getCodexConfigMetadata(forceRefresh = false) {
 // ../../packages/runtime-codex/src/codex/config-io.ts
 var import_node_crypto10 = require("crypto");
 var import_promises4 = require("fs/promises");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/config-presets.ts
 var DEFAULT_CONFIG_TEMPLATE = [
@@ -7431,10 +7506,10 @@ var YOLO_PRESET = {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 function getConfigPath(options) {
-  return import_node_path9.default.join(resolveCodexHomeDir(options), "config.toml");
+  return import_node_path10.default.join(resolveCodexHomeDir(options), "config.toml");
 }
 async function ensureConfigDirExists(filePath) {
-  const dir = import_node_path9.default.dirname(filePath);
+  const dir = import_node_path10.default.dirname(filePath);
   await (0, import_promises4.mkdir)(dir, { recursive: true });
 }
 async function resolveConfigWriteTarget(configPath) {
@@ -7448,7 +7523,7 @@ async function resolveConfigWriteTarget(configPath) {
       if (error.code !== "ENOENT") {
         throw error;
       }
-      return import_node_path9.default.resolve(import_node_path9.default.dirname(configPath), await (0, import_promises4.readlink)(configPath));
+      return import_node_path10.default.resolve(import_node_path10.default.dirname(configPath), await (0, import_promises4.readlink)(configPath));
     }
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -7458,8 +7533,8 @@ async function resolveConfigWriteTarget(configPath) {
   }
 }
 async function removeStaleConfigStagingFiles(targetPath) {
-  const directory = import_node_path9.default.dirname(targetPath);
-  const prefix = `${import_node_path9.default.basename(targetPath)}.tmp-`;
+  const directory = import_node_path10.default.dirname(targetPath);
+  const prefix = `${import_node_path10.default.basename(targetPath)}.tmp-`;
   const entries3 = await (0, import_promises4.readdir)(directory).catch((error) => {
     if (error.code === "ENOENT") {
       return [];
@@ -7467,7 +7542,7 @@ async function removeStaleConfigStagingFiles(targetPath) {
     throw error;
   });
   await Promise.all(
-    entries3.filter((entry) => entry.startsWith(prefix)).map((entry) => (0, import_promises4.rm)(import_node_path9.default.join(directory, entry), { force: true }))
+    entries3.filter((entry) => entry.startsWith(prefix)).map((entry) => (0, import_promises4.rm)(import_node_path10.default.join(directory, entry), { force: true }))
   );
 }
 async function resolveConfigWriteMode(targetPath) {
@@ -7528,7 +7603,7 @@ async function writeConfigContent(content, options) {
       await (0, import_promises4.rename)(stagingPath, targetPath);
       if (process.platform !== "win32") {
         await (0, import_promises4.chmod)(targetPath, mode);
-        const directory = await (0, import_promises4.open)(import_node_path9.default.dirname(targetPath), "r");
+        const directory = await (0, import_promises4.open)(import_node_path10.default.dirname(targetPath), "r");
         try {
           await directory.sync();
         } finally {
@@ -7551,7 +7626,7 @@ async function removeConfigContent(options) {
       }
       throw error;
     }
-    const directory = await (0, import_promises4.open)(import_node_path9.default.dirname(configPath), "r");
+    const directory = await (0, import_promises4.open)(import_node_path10.default.dirname(configPath), "r");
     try {
       await directory.sync();
     } finally {
@@ -8585,8 +8660,8 @@ var CIRCULAR = "[Circular]";
 function formatPropertyKey(name) {
   return typeof name === "string" ? JSON.stringify(name) : String(name);
 }
-function formatPath(path22) {
-  return path22.map((key) => `[${formatPropertyKey(key)}]`).join("");
+function formatPath(path23) {
+  return path23.map((key) => `[${formatPropertyKey(key)}]`).join("");
 }
 function formatDate(date) {
   try {
@@ -12107,9 +12182,9 @@ var Pointer = class extends IssueNodeImpl {
    * The issue that occurred.
    */
   issue;
-  constructor(path22, issue) {
+  constructor(path23, issue) {
     super();
-    this.path = path22;
+    this.path = path23;
     this.issue = issue;
   }
 };
@@ -12294,43 +12369,43 @@ function getExpectedMessage(expected, issue) {
   const input = formatInput(issue);
   return input === void 0 ? `Expected ${expected}` : `Expected ${expected}, got ${input}`;
 }
-function toDefaultIssues(issue, path22, leafHook, checkHook) {
+function toDefaultIssues(issue, path23, leafHook, checkHook) {
   switch (issue._tag) {
     case "Filter": {
       const message = checkHook(issue);
       if (message !== void 0) {
         return [{
-          path: path22,
+          path: path23,
           message
         }];
       }
       if (issue.issue._tag !== "InvalidValue") {
-        return toDefaultIssues(issue.issue, path22, leafHook, checkHook);
+        return toDefaultIssues(issue.issue, path23, leafHook, checkHook);
       }
       const expected = findExpected(issue.issue);
       return [{
-        path: path22,
+        path: path23,
         message: expected === void 0 ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue)
       }];
     }
     case "Encoding":
-      return toDefaultIssues(issue.issue, path22, leafHook, checkHook);
+      return toDefaultIssues(issue.issue, path23, leafHook, checkHook);
     case "Pointer":
-      return toDefaultIssues(issue.issue, [...path22, ...issue.path], leafHook, checkHook);
+      return toDefaultIssues(issue.issue, [...path23, ...issue.path], leafHook, checkHook);
     case "Composite":
-      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path22, leafHook, checkHook));
+      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path23, leafHook, checkHook));
     case "AnyOf": {
       if (issue.issues.length === 0) {
         return [{
-          path: path22,
+          path: path23,
           message: findMessage(issue) ?? getExpectedMessage(getExpected(issue.ast), issue)
         }];
       }
-      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path22, leafHook, checkHook));
+      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path23, leafHook, checkHook));
     }
     default:
       return [{
-        path: path22,
+        path: path23,
         message: leafHook(issue)
       }];
   }
@@ -12349,7 +12424,7 @@ function makeFormatterDefault() {
   return (issue) => formatIssue(issue, "");
 }
 var defaultFormatter = /* @__PURE__ */ makeFormatterDefault();
-function formatIssue(issue, path22) {
+function formatIssue(issue, path23) {
   let message;
   switch (issue._tag) {
     case "Filter": {
@@ -12358,7 +12433,7 @@ function formatIssue(issue, path22) {
         message = annotated;
       } else {
         if (issue.issue._tag !== "InvalidValue") {
-          return formatIssue(issue.issue, path22);
+          return formatIssue(issue.issue, path23);
         }
         const expected = findExpected(issue.issue);
         message = expected === void 0 ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue);
@@ -12366,13 +12441,13 @@ function formatIssue(issue, path22) {
       break;
     }
     case "Encoding":
-      return formatIssue(issue.issue, path22);
+      return formatIssue(issue.issue, path23);
     case "Pointer":
-      return formatIssue(issue.issue, path22 + formatPath(issue.path));
+      return formatIssue(issue.issue, path23 + formatPath(issue.path));
     case "Composite":
     case "AnyOf": {
       if (issue._tag === "Composite" || issue.issues.length > 0) {
-        return issue.issues.map((issue2) => formatIssue(issue2, path22)).join("\n");
+        return issue.issues.map((issue2) => formatIssue(issue2, path23)).join("\n");
       }
       message = findMessage(issue) ?? getExpectedMessage(getExpected(issue.ast), issue);
       break;
@@ -12381,8 +12456,8 @@ function formatIssue(issue, path22) {
       message = defaultLeafHook(issue);
       break;
   }
-  return path22 ? `${message}
-  at ${path22}` : message;
+  return path23 ? `${message}
+  at ${path23}` : message;
 }
 function findMessage(issue) {
   if (issue._tag === "Pointer") return;
@@ -13255,13 +13330,13 @@ var Enum = class extends ASTNodeImpl {
     return this.enums.map(([_, value3]) => JSON.stringify(value3)).join(" | ");
   }
 };
-function formatTemplateLiteralPath(path22) {
-  return typeof path22 === "number" ? `parts[${path22}]` : path22;
+function formatTemplateLiteralPath(path23) {
+  return typeof path23 === "number" ? `parts[${path23}]` : path23;
 }
-function isTemplateLiteralPart(ast, path22, validated) {
+function isTemplateLiteralPart(ast, path23, validated) {
   if (validated.has(ast)) return true;
   if (ast.encoding) {
-    throw new Error(`TemplateLiteral parts cannot have an encoding at ${formatTemplateLiteralPath(path22)}`);
+    throw new Error(`TemplateLiteral parts cannot have an encoding at ${formatTemplateLiteralPath(path23)}`);
   }
   let valid;
   switch (ast._tag) {
@@ -13274,12 +13349,12 @@ function isTemplateLiteralPart(ast, path22, validated) {
       valid = !ast.checks;
       break;
     case "TemplateLiteral": {
-      const currentPath = formatTemplateLiteralPath(path22);
+      const currentPath = formatTemplateLiteralPath(path23);
       valid = !ast.checks && ast.parts.every((part, index2) => isTemplateLiteralPart(part, `${currentPath}.parts[${index2}]`, validated));
       break;
     }
     case "Union": {
-      const currentPath = formatTemplateLiteralPath(path22);
+      const currentPath = formatTemplateLiteralPath(path23);
       valid = !ast.checks && ast.types.every((part, index2) => isTemplateLiteralPart(part, `${currentPath}.types[${index2}]`, validated));
       break;
     }
@@ -16817,8 +16892,8 @@ function parseUriFragment(fragment) {
   const pointer = decodeUriFragment(fragment);
   return pointer === void 0 ? void 0 : pointer.length === 0 ? [] : pointer.slice(1).split("/").map(unescapeToken);
 }
-function formatUriFragment(path22) {
-  return path22.reduce((fragment, token) => `${fragment}/${formatUriFragmentToken(token)}`, "#");
+function formatUriFragment(path23) {
+  return path23.reduce((fragment, token) => `${fragment}/${formatUriFragmentToken(token)}`, "#");
 }
 
 // ../../node_modules/.bun/effect@4.0.0-rc.115/node_modules/effect/dist/JsonSchema.js
@@ -17405,10 +17480,10 @@ var RegExp2 = globalThis.RegExp;
 var escape = (string3) => string3.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
 
 // ../../node_modules/.bun/effect@4.0.0-rc.115/node_modules/effect/dist/internal/errors.js
-function errorWithPath(message, path22) {
-  if (path22.length > 0) {
+function errorWithPath(message, path23) {
+  if (path23.length > 0) {
     message += `
-  at ${formatPath(path22)}`;
+  at ${formatPath(path23)}`;
   }
   return new Error(message);
 }
@@ -17570,11 +17645,11 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     schemas,
     definitions
   };
-  function compileDefinition(key, path22) {
+  function compileDefinition(key, path23) {
     const compiled = definitionStates.get(key);
     if (compiled !== void 0) return typeof compiled === "string" ? compiled : key;
     if (!Object.hasOwn(references, key)) {
-      throw errorWithPath(`Invalid reference ${key}`, [...path22, "$ref"]);
+      throw errorWithPath(`Invalid reference ${key}`, [...path23, "$ref"]);
     }
     definitionStates.set(key, null);
     const representation = references[key];
@@ -17615,14 +17690,14 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     const annotations = representation.checks.length === 0 ? representation.annotations : representation.checks[representation.checks.length - 1].annotations;
     return typeof annotations?.identifier !== "string" && typeof annotations?.[IDENTIFIER_FALLBACK_KEY] === "string" ? annotations[IDENTIFIER_FALLBACK_KEY] : void 0;
   }
-  function annotationSchemas(representation, path22) {
-    return representation?.schemas?.map((schema, index2) => recur2(schema, [...path22, "schemas", index2])) ?? [];
+  function annotationSchemas(representation, path23) {
+    return representation?.schemas?.map((schema, index2) => recur2(schema, [...path23, "schemas", index2])) ?? [];
   }
-  function compileCheck(check2, type, path22) {
+  function compileCheck(check2, type, path23) {
     const annotations = check2.annotations;
     const callback2 = annotations?.toJsonSchema;
     if (callback2 !== void 0) {
-      const schemas2 = annotationSchemas(check2.representation, [...path22, "representation"]);
+      const schemas2 = annotationSchemas(check2.representation, [...path23, "representation"]);
       const fragment = callback2({
         type,
         schemas: schemas2
@@ -17636,7 +17711,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
       return check2._tag === "Filter" && hasOnlyKeywords(schema, allowed) && (ordinary2 === void 0 || hasOnlyKeywords(ordinary2, promotableAnnotationKeywords)) ? [schema, true] : [schema];
     }
     if (check2._tag === "Filter") return void 0;
-    const children = check2.checks.map((child, index2) => compileCheck(child, type, [...path22, "checks", index2])).filter((child) => child !== void 0);
+    const children = check2.checks.map((child, index2) => compileCheck(child, type, [...path23, "checks", index2])).filter((child) => child !== void 0);
     if (children.length === 0) return void 0;
     const ordinary = collectJsonSchemaAnnotations(annotations, options);
     const allOf = children.map(([schema]) => schema);
@@ -17647,16 +17722,16 @@ function compileJsonSchema(representations, rootPaths, references, options) {
       ...ordinary
     }];
   }
-  function recur2(representation, path22) {
+  function recur2(representation, path23) {
     if (representation._tag === "Reference") {
-      const canonical = compileDefinition(representation.$ref, path22);
+      const canonical = compileDefinition(representation.$ref, path23);
       return {
         $ref: formatDefinitionReference(canonical)
       };
     }
     const cached2 = compiledRepresentations.get(representation);
     if (cached2 !== void 0) return cached2;
-    let output = on(representation, path22);
+    let output = on(representation, path23);
     const ordinary = collectJsonSchemaAnnotations(representation.annotations, options);
     if (ordinary !== void 0) {
       output = {
@@ -17666,7 +17741,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     }
     for (let index2 = 0; index2 < representation.checks.length; index2++) {
       const type = typeof output.type === "string" && isJsonSchemaType(output.type) ? output.type : void 0;
-      const check2 = compileCheck(representation.checks[index2], type, [...path22, "checks", index2]);
+      const check2 = compileCheck(representation.checks[index2], type, [...path23, "checks", index2]);
       if (check2 !== void 0) {
         output = appendJsonSchema(output, ...check2);
       }
@@ -17674,7 +17749,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     compiledRepresentations.set(representation, output);
     return output;
   }
-  function on(representation, path22) {
+  function on(representation, path23) {
     switch (representation._tag) {
       case "Any":
       case "Unknown":
@@ -17718,7 +17793,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         return {};
       }
       case "Suspend":
-        return recur2(representation.thunk, [...path22, "thunk"]);
+        return recur2(representation.thunk, [...path23, "thunk"]);
       case "Never":
         return {
           not: {}
@@ -17753,7 +17828,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
       case "Enum": {
         const types = representation.enums.map(([title, literal], index2) => {
           if (typeof literal === "number" && !globalThis.Number.isFinite(literal)) {
-            throw errorWithPath(`Invalid numeric enum value ${globalThis.String(literal)}`, [...path22, "enums", index2, 1]);
+            throw errorWithPath(`Invalid numeric enum value ${globalThis.String(literal)}`, [...path23, "enums", index2, 1]);
           }
           return {
             type: typeof literal,
@@ -17774,7 +17849,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         };
       case "Arrays": {
         if (representation.rest.length > 1) {
-          throw errorWithPath("Invalid schema representation document", [...path22, "rest"]);
+          throw errorWithPath("Invalid schema representation document", [...path23, "rest"]);
         }
         const out = {
           type: "array"
@@ -17782,7 +17857,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         let minItems = representation.elements.length;
         const prefixItems = representation.elements.map((element, index2) => {
           if (element.isOptional) minItems--;
-          const compiled = recur2(element.type, [...path22, "elements", index2, "type"]);
+          const compiled = recur2(element.type, [...path23, "elements", index2, "type"]);
           const annotations = collectJsonSchemaAnnotations(element.annotations, options);
           return annotations === void 0 ? compiled : appendJsonSchema(compiled, annotations);
         });
@@ -17795,7 +17870,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         }
         if (representation.rest.length === 1) {
           delete out.maxItems;
-          const rest = recur2(representation.rest[0], [...path22, "rest", 0]);
+          const rest = recur2(representation.rest[0], [...path23, "rest", 0]);
           if (Object.keys(rest).length > 0) out.items = rest;
           else delete out.items;
         }
@@ -17817,10 +17892,10 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         for (let index2 = 0; index2 < representation.propertySignatures.length; index2++) {
           const property = representation.propertySignatures[index2];
           if (typeof property.name !== "string") {
-            throw errorWithPath("Invalid schema representation document", [...path22, "propertySignatures", index2, "name"]);
+            throw errorWithPath("Invalid schema representation document", [...path23, "propertySignatures", index2, "name"]);
           }
           const name = property.name;
-          const compiled = recur2(property.type, [...path22, "propertySignatures", index2, "type"]);
+          const compiled = recur2(property.type, [...path23, "propertySignatures", index2, "type"]);
           const annotations = collectJsonSchemaAnnotations(property.annotations, options);
           assignProperty(properties, name, annotations === void 0 ? compiled : appendJsonSchema(compiled, annotations));
           if (!property.isOptional) required2.push(name);
@@ -17833,12 +17908,12 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         let hasUnrepresentableIndexPattern = false;
         for (let index2 = 0; index2 < representation.indexSignatures.length; index2++) {
           const signature = representation.indexSignatures[index2];
-          let type = recur2(signature.type, [...path22, "indexSignatures", index2, "type"]);
+          let type = recur2(signature.type, [...path23, "indexSignatures", index2, "type"]);
           if (equals(type, {
             not: {}
           })) type = false;
           indexValueSchemas.push(type);
-          const patterns = getParameterPatterns(signature.parameter, [...path22, "indexSignatures", index2, "parameter"], /* @__PURE__ */ new Set());
+          const patterns = getParameterPatterns(signature.parameter, [...path23, "indexSignatures", index2, "parameter"], /* @__PURE__ */ new Set());
           if (patterns === void 0) {
             hasUnrepresentableIndexPattern = true;
             continue;
@@ -17864,7 +17939,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
             });
           }
           for (let index2 = 0; index2 < representation.indexSignatures.length; index2++) {
-            propertyNames.push(recur2(representation.indexSignatures[index2].parameter, [...path22, "indexSignatures", index2, "parameter"]));
+            propertyNames.push(recur2(representation.indexSignatures[index2].parameter, [...path23, "indexSignatures", index2, "parameter"]));
           }
           out.propertyNames = propertyNames.length === 1 ? propertyNames[0] : {
             anyOf: propertyNames
@@ -17894,7 +17969,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         return out;
       }
       case "Union": {
-        const types = representation.types.map((type, index2) => recur2(type, [...path22, "types", index2]));
+        const types = representation.types.map((type, index2) => recur2(type, [...path23, "types", index2]));
         if (types.length === 0) return {
           not: {}
         };
@@ -17911,13 +17986,13 @@ function compileJsonSchema(representations, rootPaths, references, options) {
       }
     }
   }
-  function getParameterPatterns(parameter, path22, seenReferences) {
+  function getParameterPatterns(parameter, path23, seenReferences) {
     switch (parameter._tag) {
       case "Reference": {
         if (!Object.hasOwn(references, parameter.$ref)) {
-          throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path22, "$ref"]);
+          throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path23, "$ref"]);
         }
-        compileDefinition(parameter.$ref, path22);
+        compileDefinition(parameter.$ref, path23);
         if (seenReferences.has(parameter.$ref)) return void 0;
         const next = new Set(seenReferences).add(parameter.$ref);
         return getParameterPatterns(references[parameter.$ref], ["references", parameter.$ref], next);
@@ -17927,7 +18002,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         if (parameter.checks.length !== 1 || parameter.checks[0]._tag !== "Filter" || parameter.checks[0].annotations?.toJsonSchema === void 0) {
           return void 0;
         }
-        const schema = recur2(parameter, path22);
+        const schema = recur2(parameter, path23);
         return schema.type === "string" && typeof schema.pattern === "string" && hasOnlyKeywords(schema, "|type|pattern|title|description|default|examples|readOnly|writeOnly|") ? [schema.pattern] : void 0;
       }
       case "TemplateLiteral":
@@ -17938,7 +18013,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         }
         const patterns = [];
         for (let index2 = 0; index2 < parameter.types.length; index2++) {
-          const memberPatterns = getParameterPatterns(parameter.types[index2], [...path22, "types", index2], seenReferences);
+          const memberPatterns = getParameterPatterns(parameter.types[index2], [...path23, "types", index2], seenReferences);
           if (memberPatterns === void 0) return void 0;
           if (memberPatterns.length === 0) return [];
           patterns.push(...memberPatterns);
@@ -17946,7 +18021,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         return patterns;
       }
       default:
-        throw errorWithPath("Invalid schema representation document", path22);
+        throw errorWithPath("Invalid schema representation document", path23);
     }
   }
 }
@@ -18421,25 +18496,25 @@ function get3(oldValue, newValue) {
   getLoop(oldValue, newValue, "", patches);
   return patches;
 }
-function getLoop(oldValue, newValue, path22, patches) {
+function getLoop(oldValue, newValue, path23, patches) {
   if (Object.is(oldValue, newValue)) return;
   if (Array.isArray(oldValue) && Array.isArray(newValue)) {
     const len1 = oldValue.length;
     const len2 = newValue.length;
     const shared = Math.min(len1, len2);
     for (let i = 0; i < shared; i++) {
-      getLoop(oldValue[i], newValue[i], `${path22}/${i}`, patches);
+      getLoop(oldValue[i], newValue[i], `${path23}/${i}`, patches);
     }
     for (let i = len1 - 1; i >= len2; i--) {
       patches.push({
         op: "remove",
-        path: `${path22}/${i}`
+        path: `${path23}/${i}`
       });
     }
     for (let i = len1; i < len2; i++) {
       patches.push({
         op: "add",
-        path: `${path22}/${i}`,
+        path: `${path23}/${i}`,
         value: newValue[i]
       });
     }
@@ -18450,7 +18525,7 @@ function getLoop(oldValue, newValue, path22, patches) {
     const keys22 = Object.keys(newValue);
     const allKeys = Array.from(/* @__PURE__ */ new Set([...keys1, ...keys22])).sort();
     for (const key of allKeys) {
-      const keyPath = `${path22}/${escapeToken(key)}`;
+      const keyPath = `${path23}/${escapeToken(key)}`;
       const hasKey1 = Object.hasOwn(oldValue, key);
       const hasKey2 = Object.hasOwn(newValue, key);
       if (hasKey1 && hasKey2) {
@@ -18472,7 +18547,7 @@ function getLoop(oldValue, newValue, path22, patches) {
   }
   patches.push({
     op: "replace",
-    path: path22,
+    path: path23,
     value: newValue
   });
 }
@@ -18716,16 +18791,16 @@ var xml = {
 var toEquivalence = /* @__PURE__ */ memoize((ast) => {
   return recur(ast, []);
 });
-function recur(ast, path22) {
+function recur(ast, path23) {
   const annotation = resolve(ast)?.["toEquivalence"];
   if (annotation) {
-    return annotation(isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path22)) : []);
+    return annotation(isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path23)) : []);
   }
   switch (ast._tag) {
     case "Never":
       return strictEqual();
     case "Declaration":
-      return declarationEquivalence(ast, path22);
+      return declarationEquivalence(ast, path23);
     case "Null":
     case "Undefined":
     case "Void":
@@ -18743,9 +18818,9 @@ function recur(ast, path22) {
     case "TemplateLiteral":
       return equals;
     case "Arrays": {
-      const elements = ast.elements.map((e, i) => recur(e, [...path22, i]));
+      const elements = ast.elements.map((e, i) => recur(e, [...path23, i]));
       const len = ast.elements.length;
-      const rest = ast.rest.map((r, i) => recur(r, [...path22, len + i]));
+      const rest = ast.rest.map((r, i) => recur(r, [...path23, len + i]));
       return make2((a, b) => {
         if (!Array.isArray(a) || !Array.isArray(b)) {
           return false;
@@ -18780,8 +18855,8 @@ function recur(ast, path22) {
       if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
         return equals;
       }
-      const propertySignatures = ast.propertySignatures.map((ps) => recur(ps.type, [...path22, ps.name]));
-      const indexSignatures = ast.indexSignatures.map((is3) => recur(is3.type, path22));
+      const propertySignatures = ast.propertySignatures.map((ps) => recur(ps.type, [...path23, ps.name]));
+      const indexSignatures = ast.indexSignatures.map((is3) => recur(is3.type, path23));
       return make2((a, b) => {
         if (!isObject(a) || !isObject(b)) {
           return false;
@@ -18817,7 +18892,7 @@ function recur(ast, path22) {
     }
     case "Union": {
       const types = toType(ast).types;
-      const compiled = new Map(types.map((candidate, i) => [candidate, [_is(candidate), recur(ast.types[i], path22)]]));
+      const compiled = new Map(types.map((candidate, i) => [candidate, [_is(candidate), recur(ast.types[i], path23)]]));
       return make2((a, b) => {
         const candidates = getCandidates(a, types);
         for (let i = 0; i < candidates.length; i++) {
@@ -18831,41 +18906,41 @@ function recur(ast, path22) {
     }
     case "Suspend": {
       let equivalence;
-      return make2((a, b) => (equivalence ??= recur(ast.thunk(), path22))(a, b));
+      return make2((a, b) => (equivalence ??= recur(ast.thunk(), path23))(a, b));
     }
   }
 }
-function declarationEquivalence(ast, path22) {
+function declarationEquivalence(ast, path23) {
   const representation = ast.annotations?.representation;
   if (representation === void 0) return equals;
   switch (representation.id) {
     case "effect/schema/Option": {
-      const [value3] = declarationTypeParameters(ast, path22);
+      const [value3] = declarationTypeParameters(ast, path23);
       return (a, b) => a._tag === b._tag && (a._tag === "None" || value3(a.value, b.value));
     }
     case "effect/schema/Result": {
-      const [success, failure] = declarationTypeParameters(ast, path22);
+      const [success, failure] = declarationTypeParameters(ast, path23);
       return (a, b) => a._tag === b._tag && (a._tag === "Success" ? success(a.success, b.success) : failure(a.failure, b.failure));
     }
     case "effect/schema/CauseReason": {
-      const [error, defect] = declarationTypeParameters(ast, path22);
+      const [error, defect] = declarationTypeParameters(ast, path23);
       return causeReasonEquivalence(error, defect);
     }
     case "effect/schema/Cause": {
-      const [error, defect] = declarationTypeParameters(ast, path22);
+      const [error, defect] = declarationTypeParameters(ast, path23);
       return causeEquivalence(error, defect);
     }
     case "effect/schema/Exit": {
-      const [value3, error, defect] = declarationTypeParameters(ast, path22);
+      const [value3, error, defect] = declarationTypeParameters(ast, path23);
       const cause = causeEquivalence(error, defect);
       return (a, b) => a._tag === b._tag && (a._tag === "Success" ? value3(a.value, b.value) : cause(a.cause, b.cause));
     }
     case "effect/schema/ReadonlyMap": {
-      const [key, value3] = declarationTypeParameters(ast, path22);
+      const [key, value3] = declarationTypeParameters(ast, path23);
       return makeCompareMap(key, value3);
     }
     case "effect/schema/ReadonlySet":
-      return makeCompareSet(declarationTypeParameters(ast, path22)[0]);
+      return makeCompareSet(declarationTypeParameters(ast, path23)[0]);
     case "effect/schema/RegExp":
       return (a, b) => a.source === b.source && a.flags === b.flags;
     case "effect/schema/URL":
@@ -18874,8 +18949,8 @@ function declarationEquivalence(ast, path22) {
       return equals;
   }
 }
-function declarationTypeParameters(ast, path22) {
-  return ast.typeParameters.map((parameter) => recur(parameter, path22));
+function declarationTypeParameters(ast, path23) {
+  return ast.typeParameters.map((parameter) => recur(parameter, path23));
 }
 function causeReasonEquivalence(error, defect) {
   return (a, b) => {
@@ -19232,12 +19307,12 @@ var PathNode = class {
   path;
   get;
   set;
-  constructor(path22) {
-    this.path = path22;
+  constructor(path23) {
+    this.path = path23;
     this.get = (s) => {
       let out = s;
-      for (let i = 0; i < path22.length; i++) {
-        out = out[path22[i]];
+      for (let i = 0; i < path23.length; i++) {
+        out = out[path23[i]];
       }
       return out;
     };
@@ -19245,12 +19320,12 @@ var PathNode = class {
       const out = cloneShallow(s);
       let current = out;
       let i = 0;
-      for (; i < path22.length - 1; i++) {
-        const key = path22[i];
+      for (; i < path23.length - 1; i++) {
+        const key = path23[i];
         assignProperty(current, key, cloneShallow(current[key]));
         current = current[key];
       }
-      assignProperty(current, path22[i], a);
+      assignProperty(current, path23[i], a);
       return out;
     };
   }
@@ -20472,9 +20547,9 @@ var UnixPathProto = {
     return this.toJSON();
   }
 };
-var unixPathAddress = (path22) => {
+var unixPathAddress = (path23) => {
   const self = Object.create(UnixPathProto);
-  self.path = path22;
+  self.path = path23;
   return Object.freeze(self);
 };
 
@@ -25545,7 +25620,7 @@ function fingerprintAuth(content) {
 }
 async function readOptionalFile(filePath) {
   try {
-    return await import_node_fs6.promises.readFile(filePath, "utf8");
+    return await import_node_fs7.promises.readFile(filePath, "utf8");
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? error.code : null;
     if (code === "ENOENT") return null;
@@ -25553,12 +25628,12 @@ async function readOptionalFile(filePath) {
   }
 }
 async function writeAtomicPath(filePath, content) {
-  const dir = import_node_path10.default.dirname(filePath);
-  const tempPath = import_node_path10.default.join(
+  const dir = import_node_path11.default.dirname(filePath);
+  const tempPath = import_node_path11.default.join(
     dir,
-    `.${import_node_path10.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.tmp`
+    `.${import_node_path11.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.tmp`
   );
-  const handle = await import_node_fs6.promises.open(tempPath, "wx", 384);
+  const handle = await import_node_fs7.promises.open(tempPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
     await handle.sync();
@@ -25566,9 +25641,9 @@ async function writeAtomicPath(filePath, content) {
     await handle.close();
   }
   try {
-    await import_node_fs6.promises.rename(tempPath, filePath);
+    await import_node_fs7.promises.rename(tempPath, filePath);
     if (process.platform !== "win32") {
-      const dirHandle = await import_node_fs6.promises.open(dir, "r");
+      const dirHandle = await import_node_fs7.promises.open(dir, "r");
       try {
         await dirHandle.sync();
       } finally {
@@ -25576,16 +25651,16 @@ async function writeAtomicPath(filePath, content) {
       }
     }
   } finally {
-    await import_node_fs6.promises.rm(tempPath, { force: true }).catch(() => void 0);
+    await import_node_fs7.promises.rm(tempPath, { force: true }).catch(() => void 0);
   }
 }
 async function installAuthFileIfAbsent(filePath, content) {
-  const dir = import_node_path10.default.dirname(filePath);
-  const tempPath = import_node_path10.default.join(
+  const dir = import_node_path11.default.dirname(filePath);
+  const tempPath = import_node_path11.default.join(
     dir,
-    `.${import_node_path10.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.install`
+    `.${import_node_path11.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.install`
   );
-  const handle = await import_node_fs6.promises.open(tempPath, "wx", 384);
+  const handle = await import_node_fs7.promises.open(tempPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
     await handle.sync();
@@ -25593,25 +25668,25 @@ async function installAuthFileIfAbsent(filePath, content) {
     await handle.close();
   }
   try {
-    await import_node_fs6.promises.link(tempPath, filePath);
+    await import_node_fs7.promises.link(tempPath, filePath);
   } finally {
-    await import_node_fs6.promises.rm(tempPath, { force: true }).catch(() => void 0);
+    await import_node_fs7.promises.rm(tempPath, { force: true }).catch(() => void 0);
   }
 }
 async function linkAuthFileIfAbsent(sourcePath, targetPath) {
-  await import_node_fs6.promises.link(sourcePath, targetPath);
+  await import_node_fs7.promises.link(sourcePath, targetPath);
 }
 async function hasExternalOpenFileHandle(filePath) {
   if (process.platform === "linux") {
     let target;
     try {
-      target = await import_node_fs6.promises.stat(filePath);
+      target = await import_node_fs7.promises.stat(filePath);
     } catch {
       return true;
     }
     let processes;
     try {
-      processes = await import_node_fs6.promises.readdir("/proc", { withFileTypes: true });
+      processes = await import_node_fs7.promises.readdir("/proc", { withFileTypes: true });
     } catch {
       return true;
     }
@@ -25622,7 +25697,7 @@ async function hasExternalOpenFileHandle(filePath) {
       }
       const processPath = `/proc/${entry.name}`;
       try {
-        const processStats = await import_node_fs6.promises.stat(processPath);
+        const processStats = await import_node_fs7.promises.stat(processPath);
         if (currentUid !== void 0 && processStats.uid !== currentUid) {
           continue;
         }
@@ -25631,7 +25706,7 @@ async function hasExternalOpenFileHandle(filePath) {
       }
       let descriptors;
       try {
-        descriptors = await import_node_fs6.promises.readdir(`${processPath}/fd`);
+        descriptors = await import_node_fs7.promises.readdir(`${processPath}/fd`);
       } catch (error) {
         const code = error && typeof error === "object" && "code" in error ? error.code : null;
         if (code === "ENOENT" || code === "ESRCH") continue;
@@ -25639,7 +25714,7 @@ async function hasExternalOpenFileHandle(filePath) {
       }
       for (const descriptor2 of descriptors) {
         try {
-          const descriptorStats = await import_node_fs6.promises.stat(`${processPath}/fd/${descriptor2}`);
+          const descriptorStats = await import_node_fs7.promises.stat(`${processPath}/fd/${descriptor2}`);
           if (descriptorStats.dev === target.dev && descriptorStats.ino === target.ino) {
             return true;
           }
@@ -25686,9 +25761,9 @@ async function hasExternalOpenFileHandle(filePath) {
 async function cleanupAuthWriteback(filePath) {
   const paths = authWritebackPaths(filePath);
   await Promise.all([
-    import_node_fs6.promises.rm(paths.manifest, { force: true }),
-    import_node_fs6.promises.rm(paths.backup, { force: true }),
-    import_node_fs6.promises.rm(paths.replaced, { force: true })
+    import_node_fs7.promises.rm(paths.manifest, { force: true }),
+    import_node_fs7.promises.rm(paths.backup, { force: true }),
+    import_node_fs7.promises.rm(paths.replaced, { force: true })
   ]);
 }
 async function rollbackAuthWriteback(filePath, manifest) {
@@ -25709,8 +25784,8 @@ async function rollbackAuthWriteback(filePath, manifest) {
       "Codex auth changed outside CodexUse during writeback rollback; recovery files were preserved."
     );
   }
-  await import_node_fs6.promises.rename(filePath, paths.replaced);
-  if (fingerprintAuth(await import_node_fs6.promises.readFile(paths.replaced, "utf8")) !== manifest.targetFingerprint) {
+  await import_node_fs7.promises.rename(filePath, paths.replaced);
+  if (fingerprintAuth(await import_node_fs7.promises.readFile(paths.replaced, "utf8")) !== manifest.targetFingerprint) {
     const replaced = await readOptionalFile(paths.replaced);
     if (await readOptionalFile(filePath) === null && replaced !== null) {
       await installAuthFileIfAbsent(filePath, replaced);
@@ -25747,7 +25822,7 @@ async function replaceAuthFileIfCurrent(filePath, expectedCurrent, replacement)
   await writeAtomicPath(paths.manifest, JSON.stringify(manifest));
   let committed = false;
   try {
-    await import_node_fs6.promises.rename(filePath, paths.backup);
+    await import_node_fs7.promises.rename(filePath, paths.backup);
     if (await readOptionalFile(paths.backup) !== expectedCurrent) {
       throw new Error("Codex auth changed while writeback began.");
     }
@@ -25797,7 +25872,7 @@ async function acquireCodexAuthFileSystemLock(filePath) {
   }
 }
 async function acquireCodexAuthFileLock(filePath) {
-  const queueKey = import_node_path10.default.resolve(filePath);
+  const queueKey = import_node_path11.default.resolve(filePath);
   const predecessor = authFileLockQueues.get(queueKey) ?? Promise.resolve();
   let finishTurn;
   const turn = new Promise((resolve2) => {
@@ -25830,7 +25905,7 @@ async function acquireCodexAuthFileLock(filePath) {
   }
 }
 async function acquireCodexAuthFileReadLock(filePath) {
-  const queueKey = import_node_path10.default.resolve(filePath);
+  const queueKey = import_node_path11.default.resolve(filePath);
   await (authFileLockQueues.get(queueKey) ?? Promise.resolve());
   const releaseReadLock = await acquireCrossProcessFileReadLock(filePath);
   if (!releaseReadLock) {
@@ -25847,7 +25922,7 @@ async function acquireCodexAuthFileReadLock(filePath) {
 async function readAuthFileCached(filePath) {
   let stats;
   try {
-    stats = await import_node_fs6.promises.stat(filePath);
+    stats = await import_node_fs7.promises.stat(filePath);
   } catch {
     authFileCache.delete(filePath);
     return null;
@@ -25856,7 +25931,7 @@ async function readAuthFileCached(filePath) {
   if (cached2 && cached2.mtimeMs === stats.mtimeMs && cached2.size === stats.size) {
     return cached2.content;
   }
-  const content = await import_node_fs6.promises.readFile(filePath, "utf8");
+  const content = await import_node_fs7.promises.readFile(filePath, "utf8");
   authFileCache.set(filePath, {
     mtimeMs: stats.mtimeMs,
     size: stats.size,
@@ -25875,7 +25950,7 @@ async function writeAuthFileCached(filePath, content, expectedCurrent, options =
     );
     if (!written) return false;
     try {
-      const stats = await import_node_fs6.promises.stat(filePath);
+      const stats = await import_node_fs7.promises.stat(filePath);
       authFileCache.set(filePath, {
         mtimeMs: stats.mtimeMs,
         size: stats.size,
@@ -26004,9 +26079,9 @@ function parseRateLimitSnapshotFromRpcMessage(message) {
   return snapshot2;
 }
 function resolveRpcAuthPath(envOverride, authPath) {
-  return authPath ?? import_node_path10.default.join(
+  return authPath ?? import_node_path11.default.join(
     resolveCodexHomeDir({
-      codexHomePath: envOverride?.CODEX_HOME ?? (envOverride?.HOME ? import_node_path10.default.join(envOverride.HOME, ".codex") : void 0)
+      codexHomePath: envOverride?.CODEX_HOME ?? (envOverride?.HOME ? import_node_path11.default.join(envOverride.HOME, ".codex") : void 0)
     }),
     "auth.json"
   );
@@ -26014,13 +26089,13 @@ function resolveRpcAuthPath(envOverride, authPath) {
 async function fetchRateLimitsViaRpc(envOverride, options = {}) {
   const binaryPath = options.codexPath ?? await requireCodexCli();
   const sourceAuthPath = resolveRpcAuthPath(envOverride, options.authPath);
-  const tempHome = await import_node_fs6.promises.mkdtemp(import_node_path10.default.join(import_node_os3.default.tmpdir(), "codex-rpc-"));
-  const tempAuthPath = import_node_path10.default.join(tempHome, "auth.json");
+  const tempHome = await import_node_fs7.promises.mkdtemp(import_node_path11.default.join(import_node_os6.default.tmpdir(), "codex-rpc-"));
+  const tempAuthPath = import_node_path11.default.join(tempHome, "auth.json");
   let initialSourceAuth;
   try {
     const authLock = await acquireCodexAuthFileReadLock(sourceAuthPath);
     if (!authLock) {
-      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true });
+      await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true });
       return null;
     }
     try {
@@ -26029,21 +26104,22 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
       await authLock.release();
     }
     if (!initialSourceAuth) {
-      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true });
+      await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true });
       return null;
     }
-    await import_node_fs6.promises.writeFile(tempAuthPath, initialSourceAuth, {
+    await import_node_fs7.promises.writeFile(tempAuthPath, initialSourceAuth, {
       encoding: "utf8",
       mode: 384
     });
   } catch {
-    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
     return null;
   }
   const childEnv = buildCodexChildEnv({
     ...envOverride ?? {},
     HOME: tempHome,
+    USERPROFILE: tempHome,
     CODEX_HOME: tempHome,
     CODEX_SQLITE_HOME: tempHome,
     CODEX_TELEMETRY_LABEL: "codex-rpc",
@@ -26104,7 +26180,7 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     rl.close();
     await stopChildAndWait(child);
     try {
-      const updatedAuth = await import_node_fs6.promises.readFile(tempAuthPath, "utf8");
+      const updatedAuth = await import_node_fs7.promises.readFile(tempAuthPath, "utf8");
       if (updatedAuth.trim().length > 0) {
         const currentSourceAuth = await readAuthFileCached(sourceAuthPath);
         if (shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth)) {
@@ -26133,7 +26209,7 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     } catch (error) {
       logWarn("Failed to sync refreshed auth after rate-limit probe:", error);
     }
-    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -26147,15 +26223,15 @@ async function activateResetWindowViaRpc(envOverride, options = {}) {
 }
 async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAuthPath) {
   const binaryPath = options.codexPath ?? await requireCodexCli();
-  const tempHome = await import_node_fs6.promises.mkdtemp(
-    import_node_path10.default.join(import_node_os3.default.tmpdir(), "codex-activation-")
+  const tempHome = await import_node_fs7.promises.mkdtemp(
+    import_node_path11.default.join(import_node_os6.default.tmpdir(), "codex-activation-")
   );
-  const tempAuthPath = import_node_path10.default.join(tempHome, "auth.json");
+  const tempAuthPath = import_node_path11.default.join(tempHome, "auth.json");
   let initialSourceAuth;
   try {
     const authLock = await acquireCodexAuthFileReadLock(sourceAuthPath);
     if (!authLock) {
-      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true });
+      await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true });
       return { status: "skipped", reason: "auth-busy" };
     }
     try {
@@ -26164,30 +26240,30 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
       await authLock.release();
     }
     if (!initialSourceAuth) {
-      await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+      await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
       });
       return { status: "skipped", reason: "auth-missing" };
     }
-    await import_node_fs6.promises.writeFile(tempAuthPath, initialSourceAuth, {
+    await import_node_fs7.promises.writeFile(tempAuthPath, initialSourceAuth, {
       encoding: "utf8",
       mode: 384
     });
   } catch {
-    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
     return { status: "skipped", reason: "auth-missing" };
   }
   let configuredModel = null;
   try {
     const snapshot2 = await getCodexConfigSnapshot({
-      codexHomePath: import_node_path10.default.dirname(sourceAuthPath)
+      codexHomePath: import_node_path11.default.dirname(sourceAuthPath)
     });
     configuredModel = snapshot2.settings.model;
   } catch {
   }
   const activationModel = resolveActivationModel(configuredModel);
-  await import_node_fs6.promises.writeFile(
-    import_node_path10.default.join(tempHome, "config.toml"),
+  await import_node_fs7.promises.writeFile(
+    import_node_path11.default.join(tempHome, "config.toml"),
     `model = ${JSON.stringify(activationModel)}
 `,
     "utf8"
@@ -26196,6 +26272,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
   const childEnv = buildCodexChildEnv({
     ...envOverride ?? {},
     HOME: tempHome,
+    USERPROFILE: tempHome,
     CODEX_HOME: tempHome,
     CODEX_SQLITE_HOME: tempHome,
     CODEX_TELEMETRY_LABEL: "codex-reset-activation",
@@ -26324,7 +26401,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
     rl.close();
     await stopChildAndWait(child);
     try {
-      const updatedAuth = await import_node_fs6.promises.readFile(tempAuthPath, "utf8");
+      const updatedAuth = await import_node_fs7.promises.readFile(tempAuthPath, "utf8");
       if (updatedAuth.trim().length > 0) {
         const currentSourceAuth = await readAuthFileCached(sourceAuthPath);
         if (shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth)) {
@@ -26359,7 +26436,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
     } catch (error) {
       writebackError = error instanceof Error ? error : new Error(String(error));
     }
-    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    await import_node_fs7.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
     });
   }
   if (activationError && writebackError) {
@@ -26383,13 +26460,13 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
 // ../../packages/runtime-codex/src/codex/officialAppRestart.ts
 var import_node_child_process6 = require("child_process");
 var import_node_crypto13 = require("crypto");
-var import_node_fs9 = require("fs");
-var import_node_os4 = require("os");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_node_os7 = require("os");
+var import_node_path14 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/threadUsage.ts
-var import_node_fs7 = require("fs");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs8 = require("fs");
+var import_node_path12 = __toESM(require("path"), 1);
 var ROLLOUT_DIRS = ["sessions", "archived_sessions"];
 var SQLITE_EXTENSIONS = /* @__PURE__ */ new Set([".db", ".sqlite", ".sqlite3"]);
 var SILENT_TAKEOVER_HOT_WINDOW_MS = 6e4;
@@ -26401,7 +26478,7 @@ async function collectRolloutFiles(root) {
   async function visit(dir) {
     let entries3;
     try {
-      entries3 = await import_node_fs7.promises.readdir(dir, {
+      entries3 = await import_node_fs8.promises.readdir(dir, {
         withFileTypes: true,
         encoding: "utf8"
       });
@@ -26411,7 +26488,7 @@ async function collectRolloutFiles(root) {
     const childVisits = [];
     for (const entry of entries3) {
       const entryName = String(entry.name);
-      const entryPath = import_node_path11.default.join(dir, entryName);
+      const entryPath = import_node_path12.default.join(dir, entryName);
       if (entry.isDirectory()) {
         childVisits.push(visit(entryPath));
         continue;
@@ -26429,14 +26506,14 @@ async function collectRolloutFiles(root) {
 async function collectRolloutFilesStrict(root) {
   const files = [];
   async function visit(dir) {
-    const entries3 = await import_node_fs7.promises.readdir(dir, {
+    const entries3 = await import_node_fs8.promises.readdir(dir, {
       withFileTypes: true,
       encoding: "utf8"
     });
     await Promise.all(
       entries3.map(async (entry) => {
         const entryName = String(entry.name);
-        const entryPath = import_node_path11.default.join(dir, entryName);
+        const entryPath = import_node_path12.default.join(dir, entryName);
         if (entry.isDirectory()) {
           await visit(entryPath);
         } else if (entry.isFile() && entryName.startsWith("rollout-") && entryName.endsWith(".jsonl")) {
@@ -26452,9 +26529,9 @@ async function readOfficialCodexRolloutActivityHeat(profileHome) {
   let latestUpdatedAtMs = null;
   try {
     for (const dirname of ROLLOUT_DIRS) {
-      const root = import_node_path11.default.join(profileHome, dirname);
+      const root = import_node_path12.default.join(profileHome, dirname);
       try {
-        await import_node_fs7.promises.access(root);
+        await import_node_fs8.promises.access(root);
       } catch (error) {
         if (error.code === "ENOENT") {
           continue;
@@ -26463,7 +26540,7 @@ async function readOfficialCodexRolloutActivityHeat(profileHome) {
       }
       const files = await collectRolloutFilesStrict(root);
       for (const file of files) {
-        const stat3 = await import_node_fs7.promises.stat(file);
+        const stat3 = await import_node_fs8.promises.stat(file);
         if (Number.isFinite(stat3.mtimeMs)) {
           latestUpdatedAtMs = Math.max(latestUpdatedAtMs ?? 0, stat3.mtimeMs);
         }
@@ -26484,14 +26561,14 @@ async function findRolloutFileByScan(profileHome, threadId) {
   let best = null;
   const variants = threadIdVariants(threadId);
   for (const dirname of ROLLOUT_DIRS) {
-    const root = import_node_path11.default.join(profileHome, dirname);
+    const root = import_node_path12.default.join(profileHome, dirname);
     const files = await collectRolloutFiles(root);
     for (const file of files) {
-      const basename = import_node_path11.default.basename(file);
+      const basename = import_node_path12.default.basename(file);
       if (!variants.some((variant) => basename.includes(variant))) {
         continue;
       }
-      const stat3 = await import_node_fs7.promises.stat(file).catch(() => null);
+      const stat3 = await import_node_fs8.promises.stat(file).catch(() => null);
       const updatedAtMs = stat3 && Number.isFinite(stat3.mtimeMs) ? stat3.mtimeMs : null;
       if (!best || (updatedAtMs ?? 0) > (best.updatedAtMs ?? 0) || (updatedAtMs ?? 0) === (best.updatedAtMs ?? 0) && file > best.path) {
         best = { path: file, updatedAtMs };
@@ -26563,13 +26640,13 @@ function resolveRolloutPath(profileHome, rolloutPath) {
   if (!rolloutPath) {
     return null;
   }
-  return import_node_path11.default.isAbsolute(rolloutPath) ? rolloutPath : import_node_path11.default.join(profileHome, rolloutPath);
+  return import_node_path12.default.isAbsolute(rolloutPath) ? rolloutPath : import_node_path12.default.join(profileHome, rolloutPath);
 }
 async function collectSessionDatabasePaths(profileHome, sqliteHome = profileHome) {
   const paths = [];
-  const sqliteDir = import_node_path11.default.join(sqliteHome, "sqlite");
+  const sqliteDir = import_node_path12.default.join(sqliteHome, "sqlite");
   try {
-    const entries3 = await import_node_fs7.promises.readdir(sqliteDir, {
+    const entries3 = await import_node_fs8.promises.readdir(sqliteDir, {
       withFileTypes: true,
       encoding: "utf8"
     });
@@ -26578,20 +26655,20 @@ async function collectSessionDatabasePaths(profileHome, sqliteHome = profileHome
         continue;
       }
       const entryName = String(entry.name);
-      if (SQLITE_EXTENSIONS.has(import_node_path11.default.extname(entryName))) {
-        paths.push(import_node_path11.default.join(sqliteDir, entryName));
+      if (SQLITE_EXTENSIONS.has(import_node_path12.default.extname(entryName))) {
+        paths.push(import_node_path12.default.join(sqliteDir, entryName));
       }
     }
   } catch {
   }
   paths.sort((left, right) => {
-    const leftName = import_node_path11.default.basename(left);
-    const rightName = import_node_path11.default.basename(right);
+    const leftName = import_node_path12.default.basename(left);
+    const rightName = import_node_path12.default.basename(right);
     if (leftName === "codex-dev.db" && rightName !== "codex-dev.db") return -1;
     if (rightName === "codex-dev.db" && leftName !== "codex-dev.db") return 1;
     return leftName.localeCompare(rightName);
   });
-  const legacy = import_node_path11.default.join(sqliteHome, "state_5.sqlite");
+  const legacy = import_node_path12.default.join(sqliteHome, "state_5.sqlite");
   if (!paths.includes(legacy)) {
     paths.push(legacy);
   }
@@ -26651,7 +26728,7 @@ function queryThreadRecordFromTable(db, profileHome, threadId, config) {
 }
 async function readThreadRecordFromDb(profileHome, dbPath, threadId) {
   try {
-    await import_node_fs7.promises.access(dbPath);
+    await import_node_fs8.promises.access(dbPath);
   } catch {
     return null;
   }
@@ -26717,9 +26794,9 @@ async function findOfficialCodexThreadRecord(profileHome, threadId, options = {}
 
 // ../../packages/runtime-codex/src/codex/sharedHistory.ts
 var import_node_crypto12 = require("crypto");
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var HISTORY_MARKER = ".codexuse-shared-history-v1.json";
 var HISTORY_INDEX = "session_index.jsonl";
 var HISTORY_DIRECTORIES = [
@@ -26728,13 +26805,13 @@ var HISTORY_DIRECTORIES = [
   "thread-writer-locks"
 ];
 function markerPath(profileHome) {
-  return import_node_path12.default.join(profileHome, HISTORY_MARKER);
+  return import_node_path13.default.join(profileHome, HISTORY_MARKER);
 }
 function linkPointsTo(linkPath, targetPath) {
   try {
-    const metadata = (0, import_node_fs8.lstatSync)(linkPath);
+    const metadata = (0, import_node_fs9.lstatSync)(linkPath);
     if (!metadata.isSymbolicLink()) return false;
-    return import_node_path12.default.resolve(import_node_path12.default.dirname(linkPath), (0, import_node_fs8.readlinkSync)(linkPath)) === import_node_path12.default.resolve(targetPath);
+    return import_node_path13.default.resolve(import_node_path13.default.dirname(linkPath), (0, import_node_fs9.readlinkSync)(linkPath)) === import_node_path13.default.resolve(targetPath);
   } catch {
     return false;
   }
@@ -26742,9 +26819,9 @@ function linkPointsTo(linkPath, targetPath) {
 function parseMarker(profileHome) {
   try {
     const value3 = JSON.parse(
-      (0, import_node_fs8.readFileSync)(markerPath(profileHome), "utf8")
+      (0, import_node_fs9.readFileSync)(markerPath(profileHome), "utf8")
     );
-    if (value3.version !== 1 || typeof value3.sharedHome !== "string" || !import_node_path12.default.isAbsolute(value3.sharedHome) || typeof value3.sqliteHome !== "string" || !import_node_path12.default.isAbsolute(value3.sqliteHome)) {
+    if (value3.version !== 1 || typeof value3.sharedHome !== "string" || !import_node_path13.default.isAbsolute(value3.sharedHome) || typeof value3.sqliteHome !== "string" || !import_node_path13.default.isAbsolute(value3.sqliteHome)) {
       return null;
     }
     return value3;
@@ -26753,25 +26830,25 @@ function parseMarker(profileHome) {
   }
 }
 function readSharedCodexHistoryConfiguration(profileHome) {
-  const normalizedProfileHome = import_node_path12.default.resolve(profileHome);
+  const normalizedProfileHome = import_node_path13.default.resolve(profileHome);
   const marker = parseMarker(normalizedProfileHome);
-  if (!marker || import_node_path12.default.resolve(marker.sharedHome) === normalizedProfileHome) {
+  if (!marker || import_node_path13.default.resolve(marker.sharedHome) === normalizedProfileHome) {
     return null;
   }
   if (!HISTORY_DIRECTORIES.every(
     (name) => linkPointsTo(
-      import_node_path12.default.join(normalizedProfileHome, name),
-      import_node_path12.default.join(marker.sharedHome, name)
+      import_node_path13.default.join(normalizedProfileHome, name),
+      import_node_path13.default.join(marker.sharedHome, name)
     )
   ) || !linkPointsTo(
-    import_node_path12.default.join(normalizedProfileHome, HISTORY_INDEX),
-    import_node_path12.default.join(marker.sharedHome, HISTORY_INDEX)
+    import_node_path13.default.join(normalizedProfileHome, HISTORY_INDEX),
+    import_node_path13.default.join(marker.sharedHome, HISTORY_INDEX)
   )) {
     return null;
   }
   return {
-    sharedHome: import_node_path12.default.resolve(marker.sharedHome),
-    sqliteHome: import_node_path12.default.resolve(marker.sqliteHome)
+    sharedHome: import_node_path13.default.resolve(marker.sharedHome),
+    sqliteHome: import_node_path13.default.resolve(marker.sqliteHome)
   };
 }
 
@@ -31099,18 +31176,18 @@ async function startOfficialCodexBridgeActionListenerOnce(args2) {
         if (!requestId || !rememberBridgeActionId(requestId)) {
           return;
         }
-        const path22 = typeof payload.path === "string" ? payload.path.trim().slice(0, 64) : "";
+        const path23 = typeof payload.path === "string" ? payload.path.trim().slice(0, 64) : "";
         const requestHandler = officialCodexBridgeRequestHandler;
         void (async () => {
           let result2;
-          if (!path22) {
+          if (!path23) {
             result2 = { status: "failed", reason: "missing-path" };
           } else if (!requestHandler) {
             result2 = { status: "failed", reason: "no-request-handler" };
           } else {
             try {
               result2 = await requestHandler({
-                path: path22,
+                path: path23,
                 payload: payload.payload ?? null,
                 sourceProfileName: bridgeActionListenerProfiles.get(args2.debuggerUrl) ?? profileName
               });
@@ -31665,7 +31742,7 @@ var LAUNCH_LOCK_NAME = ".codexuse-launch.lock";
 var LAUNCH_LOCK_WAIT_MS = 6e4;
 async function withProfileLaunchFileLock(profileHome, work, options) {
   const accountKey = options.profileKey?.trim();
-  const lockPath = accountKey ? import_node_path13.default.join(resolveProfileCodexHomesRoot(), ".launch-locks", (0, import_node_crypto13.createHash)("sha256").update(accountKey).digest("hex")) : import_node_path13.default.join(profileHome, LAUNCH_LOCK_NAME);
+  const lockPath = accountKey ? import_node_path14.default.join(resolveProfileCodexHomesRoot(), ".launch-locks", (0, import_node_crypto13.createHash)("sha256").update(accountKey).digest("hex")) : import_node_path14.default.join(profileHome, LAUNCH_LOCK_NAME);
   const deadline = Date.now() + (options.waitMs ?? LAUNCH_LOCK_WAIT_MS);
   for (; ; ) {
     const release = await acquireCrossProcessFileLock(lockPath, { busyTimeoutMs: 0 });
@@ -31712,7 +31789,7 @@ async function readProcessRows() {
   return rows;
 }
 function getMainExecutablePath(candidate) {
-  return import_node_path13.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
+  return import_node_path14.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
 }
 function isMainProcessRow(row, candidate) {
   return row.args.includes(getMainExecutablePath(candidate));
@@ -32442,16 +32519,16 @@ async function verifyCurrentManagedProfileProof(instance, runtime, candidate, op
 }
 var devToolsActivePortPaths = (appUserDataDir) => {
   const roots = appUserDataDir ? [appUserDataDir] : [
-    import_node_path13.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "OpenAI", "Codex"),
-    import_node_path13.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "Codex"),
-    import_node_path13.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "com.openai.codex"),
-    import_node_path13.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "com.openai.chat")
+    import_node_path14.default.join((0, import_node_os7.homedir)(), "Library", "Application Support", "OpenAI", "Codex"),
+    import_node_path14.default.join((0, import_node_os7.homedir)(), "Library", "Application Support", "Codex"),
+    import_node_path14.default.join((0, import_node_os7.homedir)(), "Library", "Application Support", "com.openai.codex"),
+    import_node_path14.default.join((0, import_node_os7.homedir)(), "Library", "Application Support", "com.openai.chat")
   ];
-  return roots.map((root) => import_node_path13.default.join(root, "DevToolsActivePort"));
+  return roots.map((root) => import_node_path14.default.join(root, "DevToolsActivePort"));
 };
 var readDevToolsActivePort = async (filePath) => {
   try {
-    const text = await import_node_fs9.promises.readFile(filePath, "utf8");
+    const text = await import_node_fs10.promises.readFile(filePath, "utf8");
     const port = Number(text.split(/\r?\n/, 1)[0]);
     if (!Number.isInteger(port) || port <= 0 || port >= 65536) {
       return null;
@@ -32488,7 +32565,7 @@ function classifyOpenCodexLaunchFailure(error) {
 }
 async function openCodexWithProfileHome(candidate, profileHome, profileName, previousPids, options = {}) {
   const executablePath = getMainExecutablePath(candidate);
-  if (!(0, import_node_fs9.existsSync)(executablePath)) {
+  if (!(0, import_node_fs10.existsSync)(executablePath)) {
     return {
       opened: false,
       pid: null,
@@ -32512,7 +32589,7 @@ async function openCodexWithProfileHome(candidate, profileHome, profileName, pre
   let child;
   try {
     if (appUserDataDir) {
-      (0, import_node_fs9.mkdirSync)(appUserDataDir, { recursive: true });
+      (0, import_node_fs10.mkdirSync)(appUserDataDir, { recursive: true });
     }
     child = (0, import_node_child_process6.spawn)(
       "/usr/bin/open",
@@ -32664,14 +32741,14 @@ async function openCodexWithProfileHome(candidate, profileHome, profileName, pre
   };
 }
 function resolveCodexLaunchHome(profileHome) {
-  if (Buffer.byteLength(import_node_path13.default.join(profileHome, "ipc", "ipc.sock")) >= 100) {
+  if (Buffer.byteLength(import_node_path14.default.join(profileHome, "ipc", "ipc.sock")) >= 100) {
     throw new Error("codex-home-path-too-long");
   }
   return profileHome;
 }
 async function readBundleString(appPath, key) {
-  const plistPath = import_node_path13.default.join(appPath, "Contents", "Info.plist");
-  if (!(0, import_node_fs9.existsSync)(plistPath)) {
+  const plistPath = import_node_path14.default.join(appPath, "Contents", "Info.plist");
+  if (!(0, import_node_fs10.existsSync)(plistPath)) {
     return null;
   }
   const result2 = await runCommand2("/usr/bin/plutil", [
@@ -32690,18 +32767,18 @@ async function readBundleString(appPath, key) {
 }
 function addStandardOfficialCodexAppPaths(rawPaths) {
   for (const appName of OFFICIAL_CODEX_APP_NAMES) {
-    rawPaths.add(import_node_path13.default.join("/Applications", appName));
-    rawPaths.add(import_node_path13.default.join((0, import_node_os4.homedir)(), "Applications", appName));
+    rawPaths.add(import_node_path14.default.join("/Applications", appName));
+    rawPaths.add(import_node_path14.default.join((0, import_node_os7.homedir)(), "Applications", appName));
   }
 }
 function officialCodexAppPriority(appPath) {
-  const priority = OFFICIAL_CODEX_APP_NAMES.indexOf(import_node_path13.default.basename(appPath));
+  const priority = OFFICIAL_CODEX_APP_NAMES.indexOf(import_node_path14.default.basename(appPath));
   return priority >= 0 ? priority : OFFICIAL_CODEX_APP_NAMES.length;
 }
 async function collectCodexAppCandidates(rawPaths) {
   const candidates = [];
   for (const appPath of rawPaths) {
-    if (!(0, import_node_fs9.existsSync)(appPath) || !OFFICIAL_CODEX_APP_NAMES.includes(import_node_path13.default.basename(appPath)) || !(0, import_node_fs9.existsSync)(import_node_path13.default.join(appPath, "Contents", "Resources", "codex"))) {
+    if (!(0, import_node_fs10.existsSync)(appPath) || !OFFICIAL_CODEX_APP_NAMES.includes(import_node_path14.default.basename(appPath)) || !(0, import_node_fs10.existsSync)(import_node_path14.default.join(appPath, "Contents", "Resources", "codex"))) {
       continue;
     }
     const bundleId = await readBundleString(appPath, "CFBundleIdentifier");
@@ -32712,7 +32789,7 @@ async function collectCodexAppCandidates(rawPaths) {
       appPath,
       bundleId,
       version: await readBundleString(appPath, "CFBundleShortVersionString"),
-      executableName: await readBundleString(appPath, "CFBundleExecutable") ?? import_node_path13.default.basename(appPath, ".app")
+      executableName: await readBundleString(appPath, "CFBundleExecutable") ?? import_node_path14.default.basename(appPath, ".app")
     });
   }
   return candidates.sort(
@@ -32721,7 +32798,7 @@ async function collectCodexAppCandidates(rawPaths) {
 }
 function getRunningCodexPidsFromRows(candidate, rows) {
   const pids = /* @__PURE__ */ new Set();
-  const appContentsRoot = `${import_node_path13.default.join(candidate.appPath, "Contents")}${import_node_path13.default.sep}`;
+  const appContentsRoot = `${import_node_path14.default.join(candidate.appPath, "Contents")}${import_node_path14.default.sep}`;
   for (const row of rows) {
     if (row.args.includes(appContentsRoot)) {
       pids.add(row.pid);
@@ -32731,7 +32808,7 @@ function getRunningCodexPidsFromRows(candidate, rows) {
 }
 function getRunningCodexMainPidsFromRows(candidate, rows) {
   const pids = /* @__PURE__ */ new Set();
-  const executablePath = import_node_path13.default.join(
+  const executablePath = import_node_path14.default.join(
     candidate.appPath,
     "Contents",
     "MacOS",
@@ -32769,7 +32846,7 @@ async function resolveCodexAppTarget() {
     mainPids: getRunningCodexMainPidsFromRows(candidate, rows)
   })).filter((entry) => entry.mainPids.length > 0);
   const explicit = explicitPath ? runningCandidates.find(
-    (entry) => import_node_path13.default.resolve(entry.candidate.appPath) === import_node_path13.default.resolve(explicitPath)
+    (entry) => import_node_path14.default.resolve(entry.candidate.appPath) === import_node_path14.default.resolve(explicitPath)
   ) : null;
   if (runningCandidates.length > 1) {
     return {
@@ -32812,14 +32889,14 @@ function resolveOfficialCodexLaunchConfiguration(profileHome, options = {}) {
     sqliteHome: options.sqliteHome ?? readSharedCodexHistoryConfiguration(profileHome)?.sqliteHome ?? profileHome,
     // Managed profile windows keep Electron state separate as well as CODEX_HOME.
     // Callers can supply another isolated directory or explicitly use stock state.
-    userDataDir: options.useDefaultUserData === true ? null : options.userDataDir ?? import_node_path13.default.join(profileHome, "codex-app-user-data")
+    userDataDir: options.useDefaultUserData === true ? null : options.userDataDir ?? import_node_path14.default.join(profileHome, "codex-app-user-data")
   };
 }
 function resolveOfficialCodexThreadSqliteHome(profileHome) {
   return readSharedCodexHistoryConfiguration(profileHome)?.sqliteHome ?? profileHome;
 }
 function sharedCodexLaunchOptions(useDefaultUserData, profileIdentity) {
-  const userDataDir = !useDefaultUserData && profileIdentity ? import_node_path13.default.join(
+  const userDataDir = !useDefaultUserData && profileIdentity ? import_node_path14.default.join(
     SHARED_CODEX_HOME,
     "codex-app-user-data",
     (0, import_node_crypto13.createHash)("sha256").update(profileIdentity).digest("hex").slice(0, 16)
@@ -32986,7 +33063,7 @@ function isSharedHomeMainProcessRow(row, candidate) {
     resolveProfileCodexHomesRoot(),
     resolveLegacyProfileCodexHomesRoot()
   ];
-  return isMainProcessRow(row, candidate) && managedRoots.every((root) => !row.args.includes(`${root}${import_node_path13.default.sep}`));
+  return isMainProcessRow(row, candidate) && managedRoots.every((root) => !row.args.includes(`${root}${import_node_path14.default.sep}`));
 }
 async function hydrateSharedHomeCdpWindow(rows, candidate) {
   const isRunningCandidate = async (value3) => {
@@ -37060,8 +37137,8 @@ async function releaseProfileHomeMutationIntent(homeId, operationId) {
 }
 
 // ../../packages/runtime-profiles/src/profiles/rate-limit-cache.ts
-var import_node_fs10 = require("fs");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var import_node_path15 = __toESM(require("path"), 1);
 var memorySnapshots = /* @__PURE__ */ new Map();
 var persistedSnapshotWriteLock = Promise.resolve();
 var RATE_LIMIT_SNAPSHOT_CACHE_FILE = "rate-limit-snapshots.json";
@@ -37069,12 +37146,12 @@ function cloneSnapshot(snapshot2) {
   return JSON.parse(JSON.stringify(snapshot2));
 }
 function snapshotCachePath() {
-  return import_node_path14.default.join(getUserDataDir(), RATE_LIMIT_SNAPSHOT_CACHE_FILE);
+  return import_node_path15.default.join(getUserDataDir(), RATE_LIMIT_SNAPSHOT_CACHE_FILE);
 }
 async function loadPersistedSnapshots() {
   let raw;
   try {
-    raw = (await import_node_fs10.promises.readFile(snapshotCachePath(), "utf8")).trim();
+    raw = (await import_node_fs11.promises.readFile(snapshotCachePath(), "utf8")).trim();
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -37118,13 +37195,13 @@ async function writePersistedSnapshots(snapshots) {
     2
   );
   try {
-    await import_node_fs10.promises.mkdir(import_node_path14.default.dirname(filePath), { recursive: true });
-    await import_node_fs10.promises.writeFile(tmpPath, `${payload}
+    await import_node_fs11.promises.mkdir(import_node_path15.default.dirname(filePath), { recursive: true });
+    await import_node_fs11.promises.writeFile(tmpPath, `${payload}
 `, "utf8");
-    await import_node_fs10.promises.rename(tmpPath, filePath);
+    await import_node_fs11.promises.rename(tmpPath, filePath);
   } catch {
     try {
-      await import_node_fs10.promises.rm(tmpPath, { force: true });
+      await import_node_fs11.promises.rm(tmpPath, { force: true });
     } catch {
     }
   }
@@ -39570,7 +39647,7 @@ var ProfileManager = class {
       }
       throw error;
     }
-    const trashRoot = process.platform === "darwin" ? import_path.default.join(process.env.HOME || import_node_os5.default.homedir(), ".Trash") : import_path.default.join(getUserDataDir(), "deleted-profile-homes");
+    const trashRoot = process.platform === "darwin" ? import_path.default.join(process.env.HOME || import_node_os8.default.homedir(), ".Trash") : import_path.default.join(getUserDataDir(), "deleted-profile-homes");
     await import_fs.promises.mkdir(trashRoot, { recursive: true, mode: 448 });
     const safeName = record2.name.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 48) || "profile";
     const destination = import_path.default.join(
@@ -40559,6 +40636,7 @@ var ProfileManager = class {
     const leaseId = await this.acquireProfileRuntimeLease(record2);
     const envOverrides = buildCodexChildEnv({
       HOME: profileHome,
+      USERPROFILE: profileHome,
       CODEX_HOME: profileHome,
       CODEX_SQLITE_HOME: profileHome
     });
@@ -40679,6 +40757,7 @@ var ProfileManager = class {
           leaseId,
           env: buildCodexChildEnv({
             HOME: profileHome,
+            USERPROFILE: profileHome,
             CODEX_HOME: profileHome,
             CODEX_SQLITE_HOME: profileHome
           })
@@ -42010,6 +42089,7 @@ async function prepareManagedProfileRuntime(profileManager, profileName, options
     leaseId: null,
     env: buildCodexChildEnv({
       HOME: profileHome,
+      USERPROFILE: profileHome,
       CODEX_HOME: profileHome,
       CODEX_SQLITE_HOME: profileHome
     })
@@ -42519,7 +42599,7 @@ function pruneStore(store) {
   return store;
 }
 function resolveAccountPoolDbPath(stateDir) {
-  return import_node_path15.default.join(stateDir, "state.sqlite");
+  return import_node_path16.default.join(stateDir, "state.sqlite");
 }
 async function readStore(stateDir) {
   const dbPath = resolveAccountPoolDbPath(stateDir);
@@ -42620,9 +42700,9 @@ async function listSessions(stateDir) {
 }
 function resolveRuntimeStateDir(runtime, explicitStateDir) {
   if (explicitStateDir) {
-    return import_node_path15.default.resolve(explicitStateDir);
+    return import_node_path16.default.resolve(explicitStateDir);
   }
-  return import_node_path15.default.join(getUserDataDir(), DESKTOP_RPC_STATE_DIR);
+  return import_node_path16.default.join(getUserDataDir(), DESKTOP_RPC_STATE_DIR);
 }
 function resolveStateDir(flags) {
   const runtimeFlag = parseStringFlag(flags, "--runtime")?.trim().toLowerCase();
@@ -43071,7 +43151,7 @@ async function handleAccountPoolCommand(args2, version) {
 
 // src/commands/codex.ts
 var import_node_child_process9 = require("child_process");
-var import_node_os6 = __toESM(require("os"));
+var import_node_os9 = __toESM(require("os"));
 
 // ../../packages/runtime-profiles/src/profiles/rate-limit-notifier.ts
 function maxUsedPercent(snapshot2) {
@@ -43190,22 +43270,22 @@ async function assertProfileAccessAllowed(profileManager, profileName) {
 }
 
 // ../../packages/runtime-app-state/src/app/workspaceBindings.ts
-var import_node_fs11 = require("fs");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
+var import_node_path17 = __toESM(require("path"), 1);
 async function canonicalizeWorkspacePath(input, options = {}) {
-  const resolved = import_node_path16.default.resolve(input || process.cwd());
+  const resolved = import_node_path17.default.resolve(input || process.cwd());
   try {
-    const canonical = await import_node_fs11.promises.realpath(resolved);
+    const canonical = await import_node_fs12.promises.realpath(resolved);
     if (options.requireDirectory !== false) {
-      const stats = await import_node_fs11.promises.stat(canonical);
+      const stats = await import_node_fs12.promises.stat(canonical);
       if (!stats.isDirectory()) {
         throw new Error(`Workspace path is not a directory: ${resolved}`);
       }
     }
-    return import_node_path16.default.normalize(canonical);
+    return import_node_path17.default.normalize(canonical);
   } catch (error) {
     if (options.requireDirectory === false) {
-      return import_node_path16.default.normalize(resolved);
+      return import_node_path17.default.normalize(resolved);
     }
     const message = error instanceof Error ? error.message : String(error);
     const symptom = new Error(
@@ -43272,7 +43352,7 @@ async function resolveWorkspaceProfileBinding(requestedPath) {
         inherited: candidate !== canonical
       };
     }
-    const parent = import_node_path16.default.dirname(candidate);
+    const parent = import_node_path17.default.dirname(candidate);
     if (parent === candidate) {
       return null;
     }
@@ -43282,14 +43362,14 @@ async function resolveWorkspaceProfileBinding(requestedPath) {
 
 // src/platform/codexCli.ts
 var import_node_child_process8 = require("child_process");
-var import_node_fs12 = require("fs");
-var import_node_path17 = __toESM(require("path"));
+var import_node_fs13 = require("fs");
+var import_node_path18 = __toESM(require("path"));
 var ENV_HINTS2 = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
 function fileExists2(candidate) {
   if (!candidate) return null;
-  const resolved = import_node_path17.default.resolve(candidate);
+  const resolved = import_node_path18.default.resolve(candidate);
   try {
-    const stat3 = (0, import_node_fs12.statSync)(resolved);
+    const stat3 = (0, import_node_fs13.statSync)(resolved);
     if (stat3.isFile()) return resolved;
   } catch {
     return null;
@@ -43307,9 +43387,9 @@ function resolveFromEnv() {
 }
 function resolveFromPath() {
   const pathValue = process.env.PATH ?? "";
-  const entries3 = pathValue.split(import_node_path17.default.delimiter).filter(Boolean);
+  const entries3 = pathValue.split(import_node_path18.default.delimiter).filter(Boolean);
   for (const entry of entries3) {
-    const candidate = fileExists2(import_node_path17.default.join(entry, "codex"));
+    const candidate = fileExists2(import_node_path18.default.join(entry, "codex"));
     if (candidate) return candidate;
   }
   return null;
@@ -43490,7 +43570,7 @@ function exitCodeForSignal(signal) {
   if (!signal) return 1;
   if (signal === "SIGINT") return 130;
   if (signal === "SIGTERM") return 143;
-  const number3 = import_node_os6.default.constants.signals[signal];
+  const number3 = import_node_os9.default.constants.signals[signal];
   return typeof number3 === "number" ? 128 + number3 : 1;
 }
 async function runCodexWithProfile(manager, profileName, codexArgs) {
@@ -43757,14 +43837,14 @@ async function handleLicense(args2, version) {
 }
 
 // src/commands/profile.ts
-var import_node_fs14 = require("fs");
-var import_node_os7 = __toESM(require("os"));
-var import_node_path19 = __toESM(require("path"));
+var import_node_fs15 = require("fs");
+var import_node_os10 = __toESM(require("os"));
+var import_node_path20 = __toESM(require("path"));
 
 // ../../packages/runtime-app-state/src/app/officialCodexSwitchCoordinator.ts
 var import_node_crypto17 = require("crypto");
-var import_node_fs13 = require("fs");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs14 = require("fs");
+var import_node_path19 = __toESM(require("path"), 1);
 var DEFAULT_SWITCH_INTENT_TTL_MS = 10 * 60 * 1e3;
 var SWITCH_INTENT_RENEW_MS = 30 * 1e3;
 var PROCESS_OWNER_ID3 = (0, import_node_crypto17.randomUUID)();
@@ -44584,7 +44664,7 @@ function formatProfileLabel(name, displayName) {
 }
 var AUTO_ROLL_ACCESS_REQUIRED_MESSAGE = "Auto-roll requires a Pro license or an active trial.";
 async function withIsolatedCodexLogin(mode, action) {
-  const home = await import_node_fs14.promises.mkdtemp(import_node_path19.default.join(import_node_os7.default.tmpdir(), "codexuse-cli-login-"));
+  const home = await import_node_fs15.promises.mkdtemp(import_node_path20.default.join(import_node_os10.default.tmpdir(), "codexuse-cli-login-"));
   try {
     await runCodexLogin(mode, {
       HOME: home,
@@ -44592,9 +44672,9 @@ async function withIsolatedCodexLogin(mode, action) {
       CODEX_SQLITE_HOME: home,
       ELECTRON_RUN_AS_NODE: "1"
     });
-    return await action(import_node_path19.default.join(home, "auth.json"));
+    return await action(import_node_path20.default.join(home, "auth.json"));
   } finally {
-    await import_node_fs14.promises.rm(home, { recursive: true, force: true }).catch(() => void 0);
+    await import_node_fs15.promises.rm(home, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function assertOfficialCodexProfileStopped(profileName) {
@@ -46095,15 +46175,15 @@ async function pushRemoteSnapshot(access, snapshot2, options) {
 }
 
 // ../../packages/runtime-profiles/src/cloud-sync/journal.ts
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_crypto18 = require("crypto");
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 var JOURNAL_FILENAME = "cloud-sync-pull.journal.json";
 function getCloudSyncJournalPath() {
-  return import_node_path20.default.join(getUserDataDir(), JOURNAL_FILENAME);
+  return import_node_path21.default.join(getUserDataDir(), JOURNAL_FILENAME);
 }
 async function syncDirectory(dir) {
-  const directory = await import_node_fs15.promises.open(dir, "r");
+  const directory = await import_node_fs16.promises.open(dir, "r");
   try {
     await directory.sync();
   } finally {
@@ -46112,30 +46192,30 @@ async function syncDirectory(dir) {
 }
 async function writeCloudSyncJournal(journal) {
   const target = getCloudSyncJournalPath();
-  const dir = import_node_path20.default.dirname(target);
-  await import_node_fs15.promises.mkdir(dir, { recursive: true, mode: 448 });
-  await import_node_fs15.promises.chmod(dir, 448);
+  const dir = import_node_path21.default.dirname(target);
+  await import_node_fs16.promises.mkdir(dir, { recursive: true, mode: 448 });
+  await import_node_fs16.promises.chmod(dir, 448);
   const staging = `${target}.tmp-${process.pid}-${(0, import_node_crypto18.randomUUID)()}`;
-  await import_node_fs15.promises.writeFile(staging, JSON.stringify(journal), {
+  await import_node_fs16.promises.writeFile(staging, JSON.stringify(journal), {
     encoding: "utf8",
     flag: "wx",
     mode: 384,
     flush: true
   });
-  await import_node_fs15.promises.rename(staging, target);
+  await import_node_fs16.promises.rename(staging, target);
   await syncDirectory(dir);
 }
 async function clearCloudSyncJournal() {
   const target = getCloudSyncJournalPath();
   try {
-    await import_node_fs15.promises.unlink(target);
+    await import_node_fs16.promises.unlink(target);
   } catch (error) {
     if (error?.code === "ENOENT") {
       return;
     }
     throw error;
   }
-  await syncDirectory(import_node_path20.default.dirname(target));
+  await syncDirectory(import_node_path21.default.dirname(target));
 }
 
 // ../../packages/runtime-profiles/src/cloud-sync/encryption.ts
@@ -46932,7 +47012,7 @@ async function handleSync(args2, version) {
 }
 
 // src/commands/workspace.ts
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 function printWorkspaceHelp() {
   console.log(`Usage:
   codexuse workspace bind <path> <profile>
@@ -46962,7 +47042,7 @@ async function handleWorkspaceCommand(args2) {
       return;
     }
     for (const binding of bindings) {
-      const pathState = await import_node_fs16.promises.stat(binding.rootPath).then(() => "").catch(() => " (path missing)");
+      const pathState = await import_node_fs17.promises.stat(binding.rootPath).then(() => "").catch(() => " (path missing)");
       const profileState = profiles.has(binding.profileName) ? "" : " (profile missing)";
       console.log(`${binding.rootPath} -> ${binding.profileName}${pathState}${profileState}`);
     }
@@ -47026,7 +47106,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "6.2.12" : "0.0.0";
+var VERSION = true ? "6.3.0" : "0.0.0";
 async function runCli() {
   const args2 = process.argv.slice(2);
   if (args2.length === 0) {