codexuse-cli 6.0.5 → 6.1.0

package/dist/index.js

@@ -2026,8 +2026,8 @@ var require_toml = __commonJS({
 });
 
 // src/commands/accountPool.ts
-var import_node_crypto13 = require("crypto");
-var import_node_path13 = __toESM(require("path"));
+var import_node_crypto14 = require("crypto");
+var import_node_path14 = __toESM(require("path"));
 
 // ../../packages/contracts/src/settings/types.ts
 var DEFAULT_ACCOUNT_POOL_EXPOSED_MODELS = [
@@ -2077,9 +2077,9 @@ function migrateLegacyAccountPoolExposedReasoningDefaults(efforts) {
 }
 
 // ../../packages/runtime-app-state/src/app/state.ts
-var import_node_async_hooks = require("async_hooks");
+var import_node_async_hooks2 = require("async_hooks");
 var import_node_crypto2 = require("crypto");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var import_node_os = __toESM(require("os"), 1);
 
 // ../../packages/contracts/src/desktop/llm-compatibility.ts
@@ -2097,6 +2097,47 @@ var DESKTOP_LLM_CAPABILITY_NAMES = [
   "standaloneWebSearch",
   "imageGeneration"
 ];
+var MAX_DESKTOP_LLM_CONTEXT_TOKENS = 1e8;
+function boundedCatalogInteger(value3, minimum, maximum) {
+  return typeof value3 === "number" && Number.isInteger(value3) && value3 >= minimum && value3 <= maximum ? value3 : null;
+}
+function normalizeDesktopLlmModelCatalogMetadata(value3) {
+  const record2 = value3 && typeof value3 === "object" && !Array.isArray(value3) ? value3 : {};
+  const description = typeof record2.description === "string" ? record2.description.slice(0, 2e3).trim() || null : null;
+  const contextWindow = boundedCatalogInteger(
+    record2.contextWindow,
+    1,
+    MAX_DESKTOP_LLM_CONTEXT_TOKENS
+  );
+  const requestedMaxContextWindow = boundedCatalogInteger(
+    record2.maxContextWindow,
+    1,
+    MAX_DESKTOP_LLM_CONTEXT_TOKENS
+  );
+  const maxContextWindow = contextWindow !== null && requestedMaxContextWindow !== null && requestedMaxContextWindow < contextWindow ? contextWindow : requestedMaxContextWindow;
+  const effectiveContextWindowPercent = boundedCatalogInteger(
+    record2.effectiveContextWindowPercent,
+    1,
+    100
+  );
+  const requestedAutoCompactTokenLimit = boundedCatalogInteger(
+    record2.autoCompactTokenLimit,
+    1,
+    MAX_DESKTOP_LLM_CONTEXT_TOKENS
+  );
+  const compactContextWindow = contextWindow ?? maxContextWindow;
+  const maximumAutoCompactTokenLimit = compactContextWindow ? Math.max(
+    1,
+    Math.floor(compactContextWindow * 0.9)
+  ) : MAX_DESKTOP_LLM_CONTEXT_TOKENS;
+  return {
+    description,
+    contextWindow,
+    maxContextWindow,
+    autoCompactTokenLimit: requestedAutoCompactTokenLimit !== null && requestedAutoCompactTokenLimit <= maximumAutoCompactTokenLimit ? requestedAutoCompactTokenLimit : null,
+    effectiveContextWindowPercent
+  };
+}
 var POLICY_CAPABILITIES = /* @__PURE__ */ new Set([
   "inputImage",
   "reasoning",
@@ -3242,6 +3283,78 @@ async function deleteDocument(dbPath, namespace) {
   );
 }
 
+// ../../packages/runtime-app-state/src/storage/cloudSyncTransaction.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_path3 = __toESM(require("path"), 1);
+var CloudSyncTransactionLockError = class extends Error {
+  constructor(reason, options = {}) {
+    super(
+      reason === "busy" ? "Another CodexUse process is changing Cloud Sync data. Wait for it to finish, then try again." : "CodexUse could not open the Cloud Sync transaction lock.",
+      options
+    );
+    this.reason = reason;
+    this.name = "CloudSyncTransactionLockError";
+  }
+};
+var TRANSACTION_LOCK_NAME = "cloud-sync-transaction";
+var heldLocks = new import_node_async_hooks.AsyncLocalStorage();
+var operationTails = /* @__PURE__ */ new Map();
+function getCloudSyncTransactionLockPath(userDataDir) {
+  return import_node_path3.default.join(userDataDir, TRANSACTION_LOCK_NAME);
+}
+async function acquireTransactionLock(target, mode) {
+  const acquire = mode === "write" ? acquireCrossProcessFileLock : acquireCrossProcessFileReadLock;
+  let release;
+  try {
+    release = await acquire(target);
+  } catch (error) {
+    throw new CloudSyncTransactionLockError("unavailable", { cause: error });
+  }
+  if (release) {
+    return release;
+  }
+  throw new CloudSyncTransactionLockError("busy");
+}
+async function withCloudSyncTransaction(userDataDir, mode, operation) {
+  const target = import_node_path3.default.resolve(getCloudSyncTransactionLockPath(userDataDir));
+  const held = heldLocks.getStore();
+  const heldTransaction = held?.get(target);
+  if (heldTransaction?.active) {
+    if (heldTransaction.mode === "read" && mode === "write") {
+      throw new Error("A Cloud Sync read transaction cannot be upgraded to a write transaction.");
+    }
+    return operation();
+  }
+  const previous = operationTails.get(target) ?? Promise.resolve();
+  let finish;
+  const turn = new Promise((resolve2) => {
+    finish = resolve2;
+  });
+  operationTails.set(target, turn);
+  await previous;
+  let release = null;
+  let transaction = null;
+  try {
+    release = await acquireTransactionLock(target, mode);
+    const nextHeld = new Map(held ?? []);
+    transaction = { active: true, mode };
+    nextHeld.set(target, transaction);
+    return await heldLocks.run(nextHeld, operation);
+  } finally {
+    if (transaction) {
+      transaction.active = false;
+    }
+    try {
+      await release?.();
+    } finally {
+      finish();
+      if (operationTails.get(target) === turn) {
+        operationTails.delete(target);
+      }
+    }
+  }
+}
+
 // ../../packages/runtime-app-state/src/app/state.ts
 var APP_STATE_DOCUMENT = "desktop.app-state";
 var APP_NAME = "codexuse-desktop";
@@ -3255,7 +3368,7 @@ var persistenceFailure = null;
 var pendingRendererUiPatch = null;
 var nextPersistenceRetryAt = 0;
 var writeLock = Promise.resolve();
-var writeLockContext = new import_node_async_hooks.AsyncLocalStorage();
+var writeLockContext = new import_node_async_hooks2.AsyncLocalStorage();
 function isRecord2(value3) {
   return Boolean(value3) && typeof value3 === "object" && !Array.isArray(value3);
 }
@@ -3284,7 +3397,7 @@ function resolveDefaultUserDataDir() {
   if (!home) {
     throw new Error("Unable to resolve home directory for app state.");
   }
-  return import_node_path3.default.join(home, "Library", "Application Support", APP_NAME);
+  return import_node_path4.default.join(home, "Library", "Application Support", APP_NAME);
 }
 function getUserDataDir() {
   return configuredUserDataDir ?? resolveDefaultUserDataDir();
@@ -3369,23 +3482,12 @@ function createDefaultAppState() {
     runtimeSettings: {},
     ui: {
       themeMode: null,
-      layout: {
-        sidebarCollapsed: null
-      },
       profiles: {
-        viewMode: null,
-        sortBy: null,
-        groupBy: null,
-        planFilter: null,
-        healthFilter: null,
-        customGroupFilter: null,
-        toolbarOpen: null,
         collapsedSections: {}
       },
       onboarding: {
         welcomeCompleted: false,
         welcomeCompletedAt: null,
-        welcomeResumeStep: null,
         milestones: {
           firstProfileAdded: false,
           secondProfileAdded: false
@@ -3648,6 +3750,7 @@ function migrateDesktopLlmRegistry(profiles) {
         enabled: true,
         baseUrl: apiRoot,
         modelsPath: `${apiRoot}/models`,
+        modelsDevId: null,
         authMode: "bearer",
         credentialRef: `CODEXUSE_RELAY_${profile.id}`,
         hasCredential: profile.hasApiKey,
@@ -3687,6 +3790,7 @@ function migrateDesktopLlmRegistry(profiles) {
           displayName: profile.model,
           adapter: profile.protocol === "chat-completions" ? "openai-chat" : "openai-responses",
           path: profile.protocol === "chat-completions" ? `${apiRoot}/chat/completions` : `${apiRoot}/responses`,
+          catalogMetadata: normalizeDesktopLlmModelCatalogMetadata(null),
           capabilities: {
             streamingText: capability("streamingText", true),
             inputImage: capability("inputImage", false),
@@ -3779,6 +3883,7 @@ function normalizeDesktopLlmRegistry(value3, profiles) {
       enabled: entry.enabled === true,
       baseUrl,
       modelsPath: asString(entry.modelsPath),
+      modelsDevId: typeof entry.modelsDevId === "string" && /^[a-z0-9][a-z0-9-]{0,127}$/.test(entry.modelsDevId) ? entry.modelsDevId : null,
       authMode,
       credentialRef: asString(entry.credentialRef),
       hasCredential: entry.hasCredential === true,
@@ -3855,6 +3960,9 @@ function normalizeDesktopLlmRegistry(value3, profiles) {
       displayName,
       adapter,
       path: routePath,
+      catalogMetadata: normalizeDesktopLlmModelCatalogMetadata(
+        entry.catalogMetadata
+      ),
       capabilities,
       requestProfile: {
         reasoningStyle,
@@ -3932,6 +4040,7 @@ function normalizeDesktopLlmRegistry(value3, profiles) {
         enabled: provider.enabled,
         baseUrl: provider.baseUrl,
         modelsPath: provider.modelsPath,
+        modelsDevId: provider.modelsDevId,
         authMode: provider.authMode,
         credentialRef: provider.credentialRef,
         hasCredential: provider.hasCredential,
@@ -3948,6 +4057,7 @@ function normalizeDesktopLlmRegistry(value3, profiles) {
         displayName: route.displayName,
         adapter: route.adapter,
         path: route.path,
+        catalogMetadata: route.catalogMetadata,
         capabilities: route.capabilities,
         requestProfile: route.requestProfile,
         reasoningEffort: route.reasoningEffort,
@@ -4379,41 +4489,18 @@ function normalizeAppState(raw) {
     merged.ui = clone2(defaults.ui);
   }
   merged.ui.themeMode = merged.ui.themeMode === "light" || merged.ui.themeMode === "dark" ? merged.ui.themeMode : null;
-  if (!isRecord2(merged.ui.layout)) {
-    merged.ui.layout = clone2(defaults.ui.layout);
-  }
-  if (typeof merged.ui.layout.sidebarCollapsed !== "boolean") {
-    merged.ui.layout.sidebarCollapsed = null;
-  }
-  if (!isRecord2(merged.ui.profiles)) {
-    merged.ui.profiles = clone2(defaults.ui.profiles);
-  }
-  merged.ui.profiles.viewMode = merged.ui.profiles.viewMode === "cards" || merged.ui.profiles.viewMode === "compact" ? merged.ui.profiles.viewMode : null;
-  merged.ui.profiles.sortBy = asString(merged.ui.profiles.sortBy);
-  merged.ui.profiles.groupBy = asString(merged.ui.profiles.groupBy);
-  merged.ui.profiles.planFilter = asString(merged.ui.profiles.planFilter);
-  merged.ui.profiles.healthFilter = asString(merged.ui.profiles.healthFilter);
-  merged.ui.profiles.customGroupFilter = asString(
-    merged.ui.profiles.customGroupFilter
-  );
-  if (typeof merged.ui.profiles.toolbarOpen !== "boolean") {
-    merged.ui.profiles.toolbarOpen = null;
-  }
-  if (!isRecord2(merged.ui.profiles.collapsedSections)) {
-    merged.ui.profiles.collapsedSections = {};
-  } else {
-    merged.ui.profiles.collapsedSections = Object.fromEntries(
-      Object.entries(merged.ui.profiles.collapsedSections).flatMap(
-        ([key, value3]) => {
-          const normalizedKey = asString(key);
-          if (!normalizedKey || typeof value3 !== "boolean") {
-            return [];
-          }
-          return [[normalizedKey, value3]];
-        }
-      )
-    );
-  }
+  const collapsedProfileSections = isRecord2(merged.ui.profiles) ? merged.ui.profiles.collapsedSections : null;
+  merged.ui.profiles = {
+    collapsedSections: isRecord2(collapsedProfileSections) ? Object.fromEntries(
+      Object.entries(collapsedProfileSections).flatMap(([key, value3]) => {
+        const normalizedKey = asString(key);
+        if (!normalizedKey || typeof value3 !== "boolean") {
+          return [];
+        }
+        return [[normalizedKey, value3]];
+      })
+    ) : {}
+  };
   if (!isRecord2(merged.ui.onboarding)) {
     merged.ui.onboarding = clone2(defaults.ui.onboarding);
   }
@@ -4423,7 +4510,7 @@ function normalizeAppState(raw) {
   if (!Number.isFinite(merged.ui.onboarding.welcomeCompletedAt)) {
     merged.ui.onboarding.welcomeCompletedAt = null;
   }
-  merged.ui.onboarding.welcomeResumeStep = merged.ui.onboarding.welcomeResumeStep === 2 ? 2 : null;
+  delete merged.ui.onboarding.welcomeResumeStep;
   if (!isRecord2(merged.ui.onboarding.milestones)) {
     merged.ui.onboarding.milestones = clone2(defaults.ui.onboarding.milestones);
   }
@@ -4565,10 +4652,10 @@ function normalizeAppState(raw) {
         ([rootPath, profileName]) => {
           const normalizedRoot = asString(rootPath);
           const normalizedProfile = asString(profileName);
-          if (!normalizedRoot || !import_node_path3.default.isAbsolute(normalizedRoot) || !normalizedProfile) {
+          if (!normalizedRoot || !import_node_path4.default.isAbsolute(normalizedRoot) || !normalizedProfile) {
             return [];
           }
-          return [[import_node_path3.default.normalize(normalizedRoot), normalizedProfile]];
+          return [[import_node_path4.default.normalize(normalizedRoot), normalizedProfile]];
         }
       )
     );
@@ -4659,7 +4746,11 @@ async function ensureInitialized() {
   if (memoryState && Date.now() < nextPersistenceRetryAt) {
     return memoryState;
   }
-  const attempt = readStoredAppStateForInit();
+  const attempt = withCloudSyncTransaction(
+    getUserDataDir(),
+    "write",
+    readStoredAppStateForInit
+  );
   attempt.catch(() => void 0);
   let deadlineTimer;
   const deadline = new Promise((resolve2) => {
@@ -4724,56 +4815,77 @@ async function getAppState() {
   return state;
 }
 async function refreshAppStateCache() {
-  return withWriteLock(async () => {
-    const stored = await readStoredAppStateOrNull();
-    if (!stored) {
-      return ensureInitialized();
+  try {
+    return await withCloudSyncTransaction(
+      getUserDataDir(),
+      "write",
+      () => withWriteLock(async () => {
+        const stored = await readStoredAppStateOrNull();
+        if (!stored) {
+          return ensureInitialized();
+        }
+        appStateCache = freezeDeep(stored);
+        ephemeralAppState = null;
+        persistenceFailure = null;
+        return appStateCache;
+      })
+    );
+  } catch (error) {
+    const busyLock = error instanceof CloudSyncTransactionLockError && error.reason === "busy";
+    if (!busyLock) {
+      const cause = error instanceof CloudSyncTransactionLockError ? error.cause ?? error : error;
+      persistenceFailure = {
+        kind: classifyAppStorageFailure(cause),
+        message: cause instanceof Error ? cause.message : String(cause)
+      };
+      nextPersistenceRetryAt = Date.now() + PERSISTENCE_RETRY_COOLDOWN_MS;
     }
-    appStateCache = freezeDeep(stored);
-    ephemeralAppState = null;
-    persistenceFailure = null;
-    return appStateCache;
-  });
+    return withWriteLock(() => ensureInitialized());
+  }
 }
 async function updateAppState(transform3, options = {}) {
   const mode = options.mode ?? "patch";
-  return withWriteLock(async () => {
-    const shouldNormalize = options.normalize !== false;
-    const pendingUiPatch = pendingRendererUiPatch;
-    try {
-      const stored = await updateDocument({
-        dbPath: resolveStorageDbPath(),
-        namespace: APP_STATE_DOCUMENT,
-        normalize: normalizeAppState,
-        fallback: () => normalizeAppState(null),
-        cloneBeforeTransform: false,
-        normalizeResult: shouldNormalize,
-        cloneResult: false,
-        strictExisting: true,
-        transform: (current) => {
-          const transformed = transform3(
-            options.cloneCurrent === false ? current : clone2(current)
-          );
-          const next = mode === "replace" ? transformed : deepMerge(current, transformed);
-          return pendingUiPatch ? deepMerge(next, { ui: pendingUiPatch }) : next;
+  return withCloudSyncTransaction(
+    getUserDataDir(),
+    "write",
+    () => withWriteLock(async () => {
+      const shouldNormalize = options.normalize !== false;
+      const pendingUiPatch = pendingRendererUiPatch;
+      try {
+        const stored = await updateDocument({
+          dbPath: resolveStorageDbPath(),
+          namespace: APP_STATE_DOCUMENT,
+          normalize: normalizeAppState,
+          fallback: () => normalizeAppState(null),
+          cloneBeforeTransform: false,
+          normalizeResult: shouldNormalize,
+          cloneResult: false,
+          strictExisting: true,
+          transform: (current) => {
+            const transformed = transform3(
+              options.cloneCurrent === false ? current : clone2(current)
+            );
+            const next = mode === "replace" ? transformed : deepMerge(current, transformed);
+            return pendingUiPatch ? deepMerge(next, { ui: pendingUiPatch }) : next;
+          }
+        });
+        if (pendingRendererUiPatch === pendingUiPatch) {
+          pendingRendererUiPatch = null;
         }
-      });
-      if (pendingRendererUiPatch === pendingUiPatch) {
-        pendingRendererUiPatch = null;
+        appStateCache = freezeDeep(stored);
+        ephemeralAppState = null;
+        persistenceFailure = null;
+        return appStateCache;
+      } catch (error) {
+        persistenceFailure = {
+          kind: classifyAppStorageFailure(error),
+          message: error instanceof Error ? error.message : String(error)
+        };
+        nextPersistenceRetryAt = Date.now() + PERSISTENCE_RETRY_COOLDOWN_MS;
+        throw error;
       }
-      appStateCache = freezeDeep(stored);
-      ephemeralAppState = null;
-      persistenceFailure = null;
-      return appStateCache;
-    } catch (error) {
-      persistenceFailure = {
-        kind: classifyAppStorageFailure(error),
-        message: error instanceof Error ? error.message : String(error)
-      };
-      nextPersistenceRetryAt = Date.now() + PERSISTENCE_RETRY_COOLDOWN_MS;
-      throw error;
-    }
-  });
+    })
+  );
 }
 async function patchAppState(patch) {
   return updateAppState(() => patch, {
@@ -4833,10 +4945,6 @@ function withCurrentRuntimeDefaults(settings, options = {}) {
       changed = true;
     }
   }
-  if (next.rateLimitPercentMode !== "remaining" && next.rateLimitPercentMode !== "used") {
-    next.rateLimitPercentMode = "remaining";
-    changed = true;
-  }
   if (next.officialCodexRelayMode !== "official" && next.officialCodexRelayMode !== "off" && next.officialCodexRelayMode !== void 0) {
     next.officialCodexRelayMode = "off";
     changed = true;
@@ -4949,7 +5057,6 @@ function parseStoredTrial(raw) {
 }
 var CLOUD_SYNC_RUNTIME_SETTING_KEYS = /* @__PURE__ */ new Set([
   "keepAppRunningAfterWindowClose",
-  "rateLimitPercentMode",
   "officialCodexWideViewEnabled",
   "officialCodexWideViewMaxWidth",
   "officialCodexScrollRestoreEnabled",
@@ -5461,6 +5568,9 @@ function buildTrialInfo(stored, now2) {
     daysLeft
   };
 }
+function lockReasonFor(info) {
+  return info.expired ? "trial-ended" : null;
+}
 function buildLockedTrialInfo(stored) {
   return {
     active: false,
@@ -5604,7 +5714,7 @@ function readServerVerifiedTrial(now2) {
 }
 async function resolveTrialState(now2 = Date.now(), options = {}) {
   if (!isTrialEnforcementEnabled()) {
-    return { info: null, locked: false };
+    return { info: null, locked: false, lockReason: null };
   }
   const allowNetwork = options.allowNetwork !== false;
   const secret = await getLicenseSecret();
@@ -5619,16 +5729,20 @@ async function resolveTrialState(now2 = Date.now(), options = {}) {
       if (hasLocalClockRollback(cached2, now2)) {
         const refreshed2 = allowNetwork ? await syncAndPersistTrial({ stored: cached2, secret, now: now2 }) : null;
         if (!refreshed2) {
-          return { info: buildLockedTrialInfo(cached2), locked: true };
+          return {
+            info: buildLockedTrialInfo(cached2),
+            locked: true,
+            lockReason: "unverified"
+          };
         }
         const info3 = buildTrialInfo(refreshed2, trustedTrialNow(refreshed2, now2));
-        return { info: info3, locked: info3.expired };
+        return { info: info3, locked: info3.expired, lockReason: lockReasonFor(info3) };
       }
       if (shouldRefreshInBackground(cached2, now2)) {
         void syncTrialWithServer({ force: true }).catch(() => void 0);
       }
       const info2 = buildTrialInfo(cached2, trustedTrialNow(cached2, now2));
-      return { info: info2, locked: info2.expired };
+      return { info: info2, locked: info2.expired, lockReason: lockReasonFor(info2) };
     }
   }
   if (stored && (!currentDeviceId || !hasTrustedServerRecord(stored, secret, currentDeviceId))) {
@@ -5642,15 +5756,19 @@ async function resolveTrialState(now2 = Date.now(), options = {}) {
         startTrialSyncInBackground();
       }
       const info2 = buildTrialInfo(next, trustedTrialNow(next, now2));
-      return { info: info2, locked: info2.expired };
+      return { info: info2, locked: info2.expired, lockReason: lockReasonFor(info2) };
     }
     if (options.refreshInBackground === true) {
       startTrialSyncInBackground();
     }
     if (!hadStoredTrial && options.refreshInBackground === true) {
-      return { info: null, locked: false };
+      return { info: null, locked: false, lockReason: null };
     }
-    return { info: buildLockedTrialInfo(stored), locked: true };
+    return {
+      info: buildLockedTrialInfo(stored),
+      locked: true,
+      lockReason: "unverified"
+    };
   }
   const refreshed = await syncAndPersistTrial({ stored, secret, now: now2 });
   if (!refreshed) {
@@ -5658,12 +5776,16 @@ async function resolveTrialState(now2 = Date.now(), options = {}) {
       const next = await persistLocalSeenIfNeeded(stored, secret, now2).catch(() => stored);
       rememberServerVerifiedTrial(next, now2);
       const info2 = buildTrialInfo(next, trustedTrialNow(next, now2));
-      return { info: info2, locked: info2.expired };
+      return { info: info2, locked: info2.expired, lockReason: lockReasonFor(info2) };
     }
-    return { info: buildLockedTrialInfo(stored), locked: true };
+    return {
+      info: buildLockedTrialInfo(stored),
+      locked: true,
+      lockReason: "unverified"
+    };
   }
   const info = buildTrialInfo(refreshed, trustedTrialNow(refreshed, now2));
-  return { info, locked: info.expired };
+  return { info, locked: info.expired, lockReason: lockReasonFor(info) };
 }
 async function syncTrialWithServer(opts = {}) {
   if (!isTrialEnforcementEnabled()) {
@@ -5696,7 +5818,8 @@ var BASE_PRICE_DISPLAY = offer.basePriceDisplay;
 var PROMO_CODE = offer.couponCode;
 var PROMO_PERCENT = offer.discountPercent;
 var PROMO_ACTIVE = offer.isActive;
-var LICENSE_MAX_USES = 5;
+var LICENSE_MAX_DEVICES = 5;
+var DEFAULT_ACTIVATION_API_URL = "https://api.codexuse.com/v1/activation";
 var FREE_PROFILE_LIMIT = 2;
 var LICENSE_REFRESH_INTERVAL_MS = 5 * 60 * 1e3;
 var MAX_NEXT_CHECK_MS = 60 * 60 * 1e3;
@@ -5764,7 +5887,7 @@ function isSignatureValid2(license, secret) {
   const expected = signLicense(license, secret);
   return expected === license.signature;
 }
-async function requestGumroadVerify(licenseKey, mode) {
+async function requestGumroadVerify(licenseKey) {
   const controller = new AbortController();
   const timeout2 = setTimeout(() => controller.abort(), 1e4);
   try {
@@ -5772,7 +5895,7 @@ async function requestGumroadVerify(licenseKey, mode) {
       product_permalink: PRODUCT_PERMALINK,
       product_id: PRODUCT_ID,
       license_key: licenseKey,
-      increment_uses_count: mode === "activation" ? "true" : "false"
+      increment_uses_count: "false"
     });
     const response = await fetch("https://api.gumroad.com/v2/licenses/verify", {
       method: "POST",
@@ -5804,6 +5927,41 @@ async function requestGumroadVerify(licenseKey, mode) {
     clearTimeout(timeout2);
   }
 }
+async function requestDeviceActivation(licenseKey) {
+  const controller = new AbortController();
+  const timeout2 = setTimeout(() => controller.abort(), 1e4);
+  try {
+    const baseUrl = (process.env.CODEXUSE_ACTIVATION_API_URL?.trim() || DEFAULT_ACTIVATION_API_URL).replace(/\/+$/, "");
+    const response = await fetch(`${baseUrl}/device`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ licenseKey, deviceId: await getDeviceId() }),
+      signal: controller.signal
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) {
+      const message = typeof payload?.error === "string" && payload.error.trim() ? payload.error.trim() : `License activation failed (${response.status}).`;
+      const code = response.status >= 500 ? "network" : isExplicitRevocationMessage(message) ? "revoked" : "invalid";
+      throw new LicenseError(message, code);
+    }
+    return {
+      email: typeof payload?.purchaseEmail === "string" ? payload.purchaseEmail.trim() || null : null
+    };
+  } catch (error) {
+    if (error instanceof LicenseError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new LicenseError("License activation timed out.", "network");
+    }
+    throw new LicenseError(
+      error instanceof Error ? error.message : "Unable to reach the license server.",
+      "network"
+    );
+  } finally {
+    clearTimeout(timeout2);
+  }
+}
 function isExplicitRevocationMessage(message) {
   if (!message) {
     return false;
@@ -5811,10 +5969,10 @@ function isExplicitRevocationMessage(message) {
   const normalized = message.toLowerCase();
   return normalized.includes("revoked") || normalized.includes("refunded") || normalized.includes("chargeback") || normalized.includes("disabled") || normalized.includes("subscription") || normalized.includes("no longer active");
 }
-function normalizeVerificationResult(response, mode) {
+function normalizeVerificationResult(response) {
   if (!response.success) {
     const message = response.message ?? "License key is invalid.";
-    if (mode === "refresh" && !isExplicitRevocationMessage(message)) {
+    if (!isExplicitRevocationMessage(message)) {
       throw new LicenseError(message, "network");
     }
     throw new LicenseError(message, "invalid");
@@ -5831,20 +5989,6 @@ function normalizeVerificationResult(response, mode) {
   const email = response.purchase.email ?? null;
   return { email };
 }
-function ensureWithinUseLimit(response) {
-  if (!response.success) {
-    return;
-  }
-  if (typeof response.uses !== "number") {
-    return;
-  }
-  if (response.uses > LICENSE_MAX_USES) {
-    throw new LicenseError(
-      `This license has reached the activation limit (${LICENSE_MAX_USES}). Contact support to move it to another device.`,
-      "invalid"
-    );
-  }
-}
 function computeCapabilities(opts) {
   return {
     unlimitedProfiles: opts.entitled,
@@ -5858,7 +6002,7 @@ function applyTrial(base2, trial) {
   if (base2.isPro) {
     return { ...base2, trial: null };
   }
-  const { info, locked } = trial;
+  const { info, locked, lockReason } = trial;
   if (!info) {
     return base2;
   }
@@ -5878,6 +6022,10 @@ function applyTrial(base2, trial) {
       ...base2,
       tier: "free",
       state: "locked",
+      // From the boundary that knows. The frontend used to read expiresAt and
+      // call any lock an ended trial, but buildLockedTrialInfo keeps a stored
+      // expiresAt that can be in the future.
+      lockReason: lockReason ?? "unverified",
       capabilities: computeCapabilities({ licensed: false, entitled: false }),
       profileLimit: 0,
       profilesRemaining: 0,
@@ -5893,6 +6041,9 @@ function toLicenseStatus(stored, overrides = {}) {
   const base2 = {
     tier,
     state,
+    // applyTrial sets this when it moves the state to "locked". Nothing else
+    // locks, so nothing else has a reason.
+    lockReason: null,
     isPro,
     capabilities: computeCapabilities({ licensed: isPro, entitled: isPro }),
     trial: null,
@@ -5912,7 +6063,7 @@ function toLicenseStatus(stored, overrides = {}) {
     basePriceDisplay: BASE_PRICE_DISPLAY,
     promoCode: PROMO_ACTIVE ? PROMO_CODE : null,
     promoPercent: PROMO_ACTIVE ? PROMO_PERCENT : null,
-    maxDevices: LICENSE_MAX_USES
+    maxDevices: LICENSE_MAX_DEVICES
   };
   return { ...base2, ...overrides };
 }
@@ -5999,9 +6150,8 @@ var LicenseService = class {
     }
     const verify = async () => {
       try {
-        const result2 = await requestGumroadVerify(workingStored.licenseKey, "refresh");
-        ensureWithinUseLimit(result2);
-        const normalized = normalizeVerificationResult(result2, "refresh");
+        const result2 = await requestGumroadVerify(workingStored.licenseKey);
+        const normalized = normalizeVerificationResult(result2);
         const updated = {
           licenseKey: workingStored.licenseKey,
           purchaseEmail: normalized.email,
@@ -6058,9 +6208,7 @@ var LicenseService = class {
     }
     const secret = await getLicenseSecret();
     const digest = import_node_crypto7.default.createHash("sha256").update(trimmed).digest("hex");
-    const result2 = await requestGumroadVerify(trimmed, "activation");
-    ensureWithinUseLimit(result2);
-    const normalized = normalizeVerificationResult(result2, "activation");
+    const normalized = await requestDeviceActivation(trimmed);
     const stored = {
       licenseKey: trimmed,
       purchaseEmail: normalized.email,
@@ -6120,7 +6268,7 @@ function shouldEnforceProfileLimit(status) {
 }
 
 // ../../packages/runtime-profiles/src/profiles/profile-manager.ts
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_fs = require("fs");
 var import_node_os5 = __toESM(require("os"), 1);
 var import_path = __toESM(require("path"), 1);
@@ -6178,30 +6326,32 @@ function resolveProfileIdentityKeyFromProfile(profile) {
 }
 
 // ../../packages/runtime-codex/src/codex/rpc.ts
-var import_node_child_process5 = require("child_process");
-var import_node_crypto9 = require("crypto");
+var import_node_child_process6 = require("child_process");
+var import_node_crypto10 = 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_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/cli.ts
+var import_node_child_process3 = require("child_process");
 var import_node_fs4 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 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 homeEntries = homeDir ? [
-    import_node_path4.default.join(homeDir, ".local", "bin"),
-    import_node_path4.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
-    import_node_path4.default.join(homeDir, ".fnm", "current", "bin"),
-    import_node_path4.default.join(homeDir, ".volta", "bin"),
-    import_node_path4.default.join(homeDir, ".asdf", "shims"),
-    import_node_path4.default.join(homeDir, ".bun", "bin")
+    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")
   ] : [];
-  const configuredHints = (process.env.CODEX_PATH_HINTS ?? "").split(import_node_path4.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const configuredHints = (process.env.CODEX_PATH_HINTS ?? "").split(import_node_path5.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
   return [
     "/opt/homebrew/bin",
     "/usr/local/bin",
@@ -6213,7 +6363,7 @@ function fileExists(candidate) {
   if (!candidate) {
     return null;
   }
-  const normalized = import_node_path4.default.resolve(candidate);
+  const normalized = import_node_path5.default.resolve(candidate);
   try {
     const stats = (0, import_node_fs4.statSync)(normalized);
     if (stats.isFile()) {
@@ -6242,12 +6392,12 @@ function resolveCodexFromPath() {
     new Set(
       [
         ...getPathHintEntries(),
-        ...pathValue.split(import_node_path4.default.delimiter).map((entry) => entry.trim()).filter(Boolean)
+        ...pathValue.split(import_node_path5.default.delimiter).map((entry) => entry.trim()).filter(Boolean)
       ].filter(Boolean)
     )
   );
   for (const entry of entries3) {
-    const candidate = fileExists(import_node_path4.default.join(entry, "codex"));
+    const candidate = fileExists(import_node_path5.default.join(entry, "codex"));
     if (candidate) {
       return candidate;
     }
@@ -6289,8 +6439,59 @@ function evaluateExternalStatus() {
 function evaluateCodexCliStatus() {
   return evaluateExternalStatus();
 }
+function runVersionPreflight(cliPath) {
+  return new Promise((resolve2) => {
+    const useNode = /\.(?:c|m)?js$/i.test(cliPath);
+    const child = (0, import_node_child_process3.spawn)(
+      useNode ? process.execPath : cliPath,
+      useNode ? [cliPath, "--version"] : ["--version"],
+      {
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let output = "";
+    let settled = false;
+    const finish = (version) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout2);
+      resolve2(version);
+    };
+    const collect = (chunk) => {
+      if (output.length < 1024) {
+        output += chunk.toString();
+      }
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    child.on("error", () => finish(null));
+    child.on("close", (code) => {
+      const trimmed = output.trim();
+      const version = trimmed.match(/\b\d+\.\d+\.\d+(?:[-+][\w.-]+)?\b/)?.[0] ?? null;
+      finish(code === 0 ? version : null);
+    });
+    const timeout2 = setTimeout(() => {
+      child.kill();
+      finish(null);
+    }, 5e3);
+  });
+}
 async function refreshCodexStatus() {
-  cachedStatus = evaluateCodexCliStatus();
+  const discovered = evaluateCodexCliStatus();
+  cachedVersion = null;
+  if (discovered.available && discovered.path) {
+    cachedVersion = await runVersionPreflight(discovered.path);
+    cachedStatus = cachedVersion ? discovered : {
+      ...discovered,
+      available: false,
+      reason: "Codex CLI was found but cannot run. Repair the Codex CLI, then try again."
+    };
+  } else {
+    cachedStatus = discovered;
+  }
   return { ...cachedStatus };
 }
 var CodexCliMissingError = class extends Error {
@@ -6310,8 +6511,8 @@ async function requireCodexCli() {
 }
 
 // ../../packages/runtime-codex/src/codex/command.ts
-var import_node_child_process3 = require("child_process");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_child_process4 = require("child_process");
+var import_node_path6 = __toESM(require("path"), 1);
 var cachedNodeRuntime = null;
 function isJavaScriptEntrypoint(binaryPath) {
   const normalized = binaryPath.trim().toLowerCase();
@@ -6327,19 +6528,19 @@ function resolveNodeRuntime(env) {
   }
   const runtimeEnv = { ...process.env, ...env };
   const homeDir = runtimeEnv.HOME ?? "";
-  const pathHints = (runtimeEnv.CODEX_PATH_HINTS ?? process.env.CODEX_PATH_HINTS ?? "").split(import_node_path5.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const pathHints = (runtimeEnv.CODEX_PATH_HINTS ?? process.env.CODEX_PATH_HINTS ?? "").split(import_node_path6.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
   const extraPathEntries = [
     "/usr/local/bin",
     "/opt/homebrew/bin",
-    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_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"),
     ...pathHints
   ].filter(Boolean);
   const currentPath = runtimeEnv.PATH ?? "";
   runtimeEnv.PATH = Array.from(
-    /* @__PURE__ */ new Set([...extraPathEntries, ...currentPath.split(import_node_path5.default.delimiter).filter(Boolean)])
-  ).join(import_node_path5.default.delimiter);
+    /* @__PURE__ */ new Set([...extraPathEntries, ...currentPath.split(import_node_path6.default.delimiter).filter(Boolean)])
+  ).join(import_node_path6.default.delimiter);
   const candidates = Array.from(
     new Set(
       [
@@ -6353,7 +6554,7 @@ function resolveNodeRuntime(env) {
     )
   );
   for (const candidate of candidates) {
-    const probe = (0, import_node_child_process3.spawnSync)(candidate, ["-v"], { env: runtimeEnv, stdio: "ignore" });
+    const probe = (0, import_node_child_process4.spawnSync)(candidate, ["-v"], { env: runtimeEnv, stdio: "ignore" });
     if (!probe.error && probe.status === 0) {
       cachedNodeRuntime = candidate;
       return candidate;
@@ -6382,7 +6583,7 @@ var import_node_crypto8 = require("crypto");
 var import_node_fs5 = require("fs");
 var import_promises2 = require("fs/promises");
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 function resolveHomeDir() {
   return process.env.HOME || import_node_os2.default.homedir();
 }
@@ -6391,7 +6592,7 @@ function expandHomePrefix(input, homeDir) {
     return homeDir;
   }
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return import_node_path6.default.join(homeDir, input.slice(2));
+    return import_node_path7.default.join(homeDir, input.slice(2));
   }
   return input;
 }
@@ -6407,23 +6608,23 @@ function normalizeCodexHomePath(input) {
   if (!configured) {
     return null;
   }
-  return import_node_path6.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
+  return import_node_path7.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
 }
 function resolveDefaultCodexHomeDir() {
-  return normalizeCodexHomePath(process.env.CODEX_HOME) ?? import_node_path6.default.join(resolveHomeDir(), ".codex");
+  return normalizeCodexHomePath(process.env.CODEX_HOME) ?? import_node_path7.default.join(resolveHomeDir(), ".codex");
 }
 function resolveCodexSqliteHomeDir(codexHomePath) {
   return normalizeCodexHomePath(process.env.CODEX_SQLITE_HOME) ?? resolveCodexHomeDir({ codexHomePath });
 }
 function resolveCurrentProfileCodexHomeDir(profileHomeId) {
-  return import_node_path6.default.join(
+  return import_node_path7.default.join(
     resolveProfileCodexHomesRoot(),
     (0, import_node_crypto8.createHash)("sha256").update(profileHomeId).digest("hex").slice(0, 20)
   );
 }
 function resolveProfileCodexHomeDir(profileHomeId) {
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const legacy = import_node_path6.default.join(resolveLegacyProfileCodexHomesRoot(), 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);
   if (currentExists && legacyExists) {
@@ -6433,15 +6634,15 @@ function resolveProfileCodexHomeDir(profileHomeId) {
 }
 function findProfileCodexHomeLocationConflict(profileHomeId) {
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
-  const legacy = import_node_path6.default.join(resolveLegacyProfileCodexHomesRoot(), 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;
 }
 function resolveProfileCodexHomesRoot() {
-  return import_node_path6.default.join(resolveHomeDir(), ".codexuse", "p");
+  return import_node_path7.default.join(resolveHomeDir(), ".codexuse", "p");
 }
 async function ensureProfileCodexHomesRoot() {
   const root = resolveProfileCodexHomesRoot();
-  const parent = import_node_path6.default.dirname(root);
+  const parent = import_node_path7.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") {
@@ -6451,10 +6652,10 @@ async function ensureProfileCodexHomesRoot() {
   return root;
 }
 function resolveLegacyProfileCodexHomesRoot() {
-  return import_node_path6.default.join(getUserDataDir(), "profile-homes");
+  return import_node_path7.default.join(getUserDataDir(), "profile-homes");
 }
 async function migrateProfileCodexHomeDir(profileHomeId) {
-  const legacy = import_node_path6.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  const legacy = import_node_path7.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
   const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
   const currentExists = (0, import_node_fs5.existsSync)(current);
   const legacyExists = (0, import_node_fs5.existsSync)(legacy);
@@ -6531,9 +6732,9 @@ function buildCodexChildEnv(overrides = {}) {
 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_node_child_process5 = require("child_process");
 var import_promises3 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path8 = __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 = [
@@ -6643,7 +6844,7 @@ function uniqueSorted(values2) {
 }
 async function runCommand(command, args2, timeoutMs = 3e3) {
   return new Promise((resolve2, reject) => {
-    const child = (0, import_node_child_process4.spawn)(command, args2, {
+    const child = (0, import_node_child_process5.spawn)(command, args2, {
       stdio: ["ignore", "pipe", "pipe"],
       env: buildCodexChildEnv()
     });
@@ -6719,8 +6920,8 @@ function parseSchemaKeys(schemaRaw) {
 async function readSchemaFromLocal() {
   const candidates = [
     process.env.CODEX_CONFIG_SCHEMA_PATH,
-    import_node_path7.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
-    import_node_path7.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
+    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")
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
     try {
@@ -6824,8 +7025,9 @@ async function getCodexConfigMetadata(forceRefresh = false) {
 }
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
+var import_node_crypto9 = require("crypto");
 var import_promises4 = require("fs/promises");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/config-presets.ts
 var DEFAULT_CONFIG_TEMPLATE = [
@@ -6868,12 +7070,55 @@ var YOLO_PRESET = {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 function getConfigPath(options) {
-  return import_node_path8.default.join(resolveCodexHomeDir(options), "config.toml");
+  return import_node_path9.default.join(resolveCodexHomeDir(options), "config.toml");
 }
 async function ensureConfigDirExists(filePath) {
-  const dir = import_node_path8.default.dirname(filePath);
+  const dir = import_node_path9.default.dirname(filePath);
   await (0, import_promises4.mkdir)(dir, { recursive: true });
 }
+async function resolveConfigWriteTarget(configPath) {
+  try {
+    if (!(await (0, import_promises4.lstat)(configPath)).isSymbolicLink()) {
+      return configPath;
+    }
+    try {
+      return await (0, import_promises4.realpath)(configPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      return import_node_path9.default.resolve(import_node_path9.default.dirname(configPath), await (0, import_promises4.readlink)(configPath));
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return configPath;
+    }
+    throw error;
+  }
+}
+async function removeStaleConfigStagingFiles(targetPath) {
+  const directory = import_node_path9.default.dirname(targetPath);
+  const prefix = `${import_node_path9.default.basename(targetPath)}.tmp-`;
+  const entries3 = await (0, import_promises4.readdir)(directory).catch((error) => {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    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 }))
+  );
+}
+async function resolveConfigWriteMode(targetPath) {
+  try {
+    return (await (0, import_promises4.stat)(targetPath)).mode & 511;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return 384;
+    }
+    throw error;
+  }
+}
 function normalizeLineEndings(content) {
   return content.replace(/\r\n/g, "\n");
 }
@@ -6882,29 +7127,76 @@ function ensureTrailingNewline(content) {
 `;
 }
 async function readConfigContent(options) {
-  const configPath = getConfigPath(options);
-  try {
-    const content = await (0, import_promises4.readFile)(configPath, "utf8");
-    return {
-      exists: true,
-      content: normalizeLineEndings(content)
-    };
-  } catch (error) {
-    const nodeError = error;
-    if (nodeError.code === "ENOENT") {
+  return withCloudSyncTransaction(getUserDataDir(), "read", async () => {
+    const configPath = getConfigPath(options);
+    try {
+      const content = await (0, import_promises4.readFile)(configPath, "utf8");
       return {
-        exists: false,
-        content: DEFAULT_CONFIG_TEMPLATE
+        exists: true,
+        content: normalizeLineEndings(content)
       };
+    } catch (error) {
+      const nodeError = error;
+      if (nodeError.code === "ENOENT") {
+        return {
+          exists: false,
+          content: DEFAULT_CONFIG_TEMPLATE
+        };
+      }
+      throw error;
     }
-    throw error;
-  }
+  });
 }
 async function writeConfigContent(content, options) {
-  const configPath = getConfigPath(options);
-  await ensureConfigDirExists(configPath);
-  const normalized = ensureTrailingNewline(normalizeLineEndings(content));
-  await (0, import_promises4.writeFile)(configPath, normalized, "utf8");
+  await withCloudSyncTransaction(getUserDataDir(), "write", async () => {
+    const configPath = getConfigPath(options);
+    await ensureConfigDirExists(configPath);
+    const targetPath = await resolveConfigWriteTarget(configPath);
+    await removeStaleConfigStagingFiles(targetPath);
+    const mode = await resolveConfigWriteMode(targetPath);
+    const normalized = ensureTrailingNewline(normalizeLineEndings(content));
+    const stagingPath = `${targetPath}.tmp-${process.pid}-${(0, import_node_crypto9.randomUUID)()}`;
+    try {
+      const handle = await (0, import_promises4.open)(stagingPath, "wx", mode);
+      try {
+        await handle.writeFile(normalized, "utf8");
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      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");
+        try {
+          await directory.sync();
+        } finally {
+          await directory.close();
+        }
+      }
+    } finally {
+      await (0, import_promises4.rm)(stagingPath, { force: true });
+    }
+  });
+}
+async function removeConfigContent(options) {
+  await withCloudSyncTransaction(getUserDataDir(), "write", async () => {
+    const configPath = getConfigPath(options);
+    try {
+      await (0, import_promises4.unlink)(configPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+    const directory = await (0, import_promises4.open)(import_node_path9.default.dirname(configPath), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  });
 }
 async function getUpdatedAt(configPath, exists) {
   if (!exists) {
@@ -6922,191 +7214,6 @@ async function getUpdatedAt(configPath, exists) {
   }
 }
 
-// ../../packages/shared/src/core/errors.ts
-var ANSI_PATTERN = /\u001B\[[0-9;]*m/g;
-function stripAnsi(value3) {
-  return value3.replace(ANSI_PATTERN, "");
-}
-function normalizeWhitespace(value3) {
-  return value3.replace(/\s+/g, " ").trim();
-}
-function compactErrorText(value3, maxLength = 220) {
-  if (!value3) {
-    return "";
-  }
-  const cleaned = normalizeWhitespace(stripAnsi(String(value3)));
-  if (!cleaned) {
-    return "";
-  }
-  if (cleaned.length <= maxLength) {
-    return cleaned;
-  }
-  return `${cleaned.slice(0, maxLength).trimEnd()}\u2026`;
-}
-function createErrorReferenceId() {
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`.toUpperCase();
-}
-function serializeUnknownError(value3) {
-  if (typeof value3 === "string") {
-    return value3;
-  }
-  if (value3 instanceof Error) {
-    return value3.stack ?? value3.message;
-  }
-  try {
-    return JSON.stringify(value3);
-  } catch {
-    return String(value3);
-  }
-}
-function extractRawMessage(error) {
-  if (error === null || typeof error === "undefined") {
-    return "";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-function normalizeRawMessage(rawMessage) {
-  let cleaned = normalizeWhitespace(stripAnsi(rawMessage));
-  if (!cleaned) {
-    return "";
-  }
-  if (cleaned.startsWith("Error invoking remote method")) {
-    cleaned = cleaned.replace(/^Error invoking remote method '[^']+': Error: /, "");
-  }
-  if (cleaned.toLowerCase().includes("openai codex") && cleaned.toLowerCase().includes("workdir:")) {
-    const parts = cleaned.split(/error:/i);
-    if (parts.length > 1) {
-      return parts[parts.length - 1]?.trim() ?? cleaned;
-    }
-  }
-  return cleaned;
-}
-function resolveCategory(cleaned, options) {
-  const lower = cleaned.toLowerCase();
-  if (options.notFoundFallback && (lower.includes("enoent") || lower.includes("not found"))) {
-    return {
-      code: "ERR_NOT_FOUND",
-      title: "We couldn't find that item",
-      message: options.notFoundFallback,
-      recovery: "Check the path or selection, then try again.",
-      retryable: true
-    };
-  }
-  if (lower.includes("rate limit") || lower.includes("quota exceeded") || lower.includes("too many requests") || lower.includes("429")) {
-    return {
-      code: "ERR_RATE_LIMIT",
-      title: "Rate limit reached",
-      message: "The provider is rate limited right now.",
-      recovery: "Wait a moment, switch profiles, or try again.",
-      retryable: true
-    };
-  }
-  if (lower.includes("timeout") || lower.includes("timed out")) {
-    return {
-      code: "ERR_TIMEOUT",
-      title: "Request timed out",
-      message: "The operation took too long to finish.",
-      recovery: "Check the connection and try again.",
-      retryable: true
-    };
-  }
-  if (lower.includes("network") || lower.includes("econn") || lower.includes("networkerror") || lower.includes("connection refused") || lower.includes("socket hang up")) {
-    return {
-      code: "ERR_NETWORK",
-      title: "Can't reach the service",
-      message: "CodexUse couldn't connect to the required service.",
-      recovery: "Check your internet or local server connection, then retry.",
-      retryable: true
-    };
-  }
-  if (lower.includes("token_invalidated") || lower.includes("session invalidated") || lower.includes("session expired") || lower.includes("refresh token") || lower.includes("unauthorized") || lower.includes("401")) {
-    return {
-      code: "ERR_AUTH",
-      title: "Sign-in expired",
-      message: "This account needs to sign in again.",
-      recovery: "Reconnect the profile, then retry the action.",
-      retryable: true
-    };
-  }
-  if (lower.includes("permission") || lower.includes("eacces") || lower.includes("operation not permitted")) {
-    return {
-      code: "ERR_PERMISSION",
-      title: "Permission denied",
-      message: "CodexUse doesn't have permission to do that.",
-      recovery: "Check the file permissions or restart the app and try again.",
-      retryable: true
-    };
-  }
-  if (lower.includes("enospc") || lower.includes("disk full") || lower.includes("no space left")) {
-    return {
-      code: "ERR_DISK_FULL",
-      title: "Disk is full",
-      message: "CodexUse couldn't save data because the disk is full.",
-      recovery: "Free up disk space, then try again.",
-      retryable: true
-    };
-  }
-  if (lower.includes("codex cli") || lower.includes("command not found") || lower.includes("spawn codex") || lower.includes("could not find codex")) {
-    return {
-      code: "ERR_CLI_UNAVAILABLE",
-      title: "Codex CLI unavailable",
-      message: "CodexUse couldn't start the Codex CLI.",
-      recovery: "Check Runtime > Codex and confirm the CLI is installed correctly.",
-      retryable: true
-    };
-  }
-  if (lower.includes("provider") || lower.includes("model") || lower.includes("openai") || lower.includes("anthropic")) {
-    return {
-      code: "ERR_PROVIDER",
-      title: "Provider request failed",
-      message: "The AI provider rejected or failed the request.",
-      recovery: "Try again, or switch the active profile or model.",
-      retryable: true
-    };
-  }
-  return {
-    code: "ERR_UNKNOWN",
-    title: "That did not work",
-    message: options.fallback,
-    recovery: "Try again. If it keeps happening, report the error with the reference below.",
-    retryable: true
-  };
-}
-function resolveUserFacingError(error, options = {}) {
-  const fallback = options.fallback ?? "That action did not complete.";
-  const rawMessage = extractRawMessage(error);
-  const cleaned = normalizeRawMessage(rawMessage);
-  const category = resolveCategory(cleaned, {
-    fallback,
-    ...options.notFoundFallback ? { notFoundFallback: options.notFoundFallback } : {}
-  });
-  return {
-    ...category,
-    referenceId: createErrorReferenceId(),
-    technicalMessage: compactErrorText(cleaned || rawMessage || fallback, 400),
-    technicalDetails: compactErrorText(serializeUnknownError(error), 4e3)
-  };
-}
-function formatUserFacingError(error, options = {}) {
-  const info = resolveUserFacingError(error, options);
-  const maxLength = typeof options.maxLength === "number" ? options.maxLength : 220;
-  const withRecovery = info.recovery && !/try again/i.test(info.message) ? `${info.message} ${info.recovery}` : info.message;
-  if (withRecovery.length <= maxLength) {
-    return withRecovery;
-  }
-  let cleaned = info.message;
-  if (cleaned.length > maxLength) {
-    cleaned = `${cleaned.slice(0, maxLength).trimEnd()}\u2026`;
-  }
-  return cleaned;
-}
-
 // ../../packages/runtime-codex/src/codex/config.ts
 function tryParseToml(content) {
   try {
@@ -7114,14 +7221,10 @@ function tryParseToml(content) {
     return { data: parsed ?? {}, error: null };
   } catch (error) {
     const maybe = error;
-    const line = typeof maybe?.line === "number" ? maybe.line : null;
-    const column = typeof maybe?.column === "number" ? maybe.column : typeof maybe?.col === "number" ? maybe.col : null;
+    const line = typeof maybe?.line === "number" ? maybe.line + 1 : null;
+    const column = typeof maybe?.col === "number" ? maybe.col + 1 : null;
     const location = line !== null ? `line ${line}${column !== null ? `, column ${column}` : ""}` : null;
-    const friendly = formatUserFacingError(error, {
-      fallback: "Invalid config.toml syntax. Fix it and try again.",
-      maxLength: 180
-    });
-    const message = location ? `${friendly} (near ${location}).` : friendly;
+    const message = location ? `Invalid config.toml syntax near ${location}. Fix it and try again.` : "Invalid config.toml syntax. Fix it and try again.";
     return { data: null, error: message };
   }
 }
@@ -7419,12 +7522,16 @@ async function getCodexConfigSnapshot(options) {
   const { content, exists } = await readConfigContent(options);
   return buildSnapshot(content, exists, options);
 }
-async function saveCodexConfigContent(content, options) {
+function assertValidCodexConfigContent(content) {
   const normalized = ensureTrailingNewline(normalizeLineEndings(content));
   const parsed = tryParseToml(normalized);
   if (!parsed.data) {
     throw new Error(parsed.error ?? "config.toml contains invalid TOML syntax.");
   }
+  return normalized;
+}
+async function saveCodexConfigContent(content, options) {
+  const normalized = assertValidCodexConfigContent(content);
   await writeConfigContent(normalized, options);
   return buildSnapshot(normalized, true, options);
 }
@@ -8108,8 +8215,8 @@ var CIRCULAR = "[Circular]";
 function formatPropertyKey(name) {
   return typeof name === "string" ? JSON.stringify(name) : String(name);
 }
-function formatPath(path19) {
-  return path19.map((key) => `[${formatPropertyKey(key)}]`).join("");
+function formatPath(path21) {
+  return path21.map((key) => `[${formatPropertyKey(key)}]`).join("");
 }
 function formatDate(date) {
   try {
@@ -11620,9 +11727,9 @@ var Pointer = class extends Base {
    * The issue that occurred.
    */
   issue;
-  constructor(path19, issue) {
+  constructor(path21, issue) {
     super();
-    this.path = path19;
+    this.path = path21;
     this.issue = issue;
   }
 };
@@ -11807,43 +11914,43 @@ function getExpectedMessage(expected, issue) {
   const input = formatInput(issue);
   return input === void 0 ? `Expected ${expected}` : `Expected ${expected}, got ${input}`;
 }
-function toDefaultIssues(issue, path19, leafHook, checkHook) {
+function toDefaultIssues(issue, path21, leafHook, checkHook) {
   switch (issue._tag) {
     case "Filter": {
       const message = checkHook(issue);
       if (message !== void 0) {
         return [{
-          path: path19,
+          path: path21,
           message
         }];
       }
       if (issue.issue._tag !== "InvalidValue") {
-        return toDefaultIssues(issue.issue, path19, leafHook, checkHook);
+        return toDefaultIssues(issue.issue, path21, leafHook, checkHook);
       }
       const expected = findExpected(issue.issue);
       return [{
-        path: path19,
+        path: path21,
         message: expected === void 0 ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue)
       }];
     }
     case "Encoding":
-      return toDefaultIssues(issue.issue, path19, leafHook, checkHook);
+      return toDefaultIssues(issue.issue, path21, leafHook, checkHook);
     case "Pointer":
-      return toDefaultIssues(issue.issue, [...path19, ...issue.path], leafHook, checkHook);
+      return toDefaultIssues(issue.issue, [...path21, ...issue.path], leafHook, checkHook);
     case "Composite":
-      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path19, leafHook, checkHook));
+      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path21, leafHook, checkHook));
     case "AnyOf": {
       if (issue.issues.length === 0) {
         return [{
-          path: path19,
+          path: path21,
           message: findMessage(issue) ?? getExpectedMessage(getExpected(issue.ast), issue)
         }];
       }
-      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path19, leafHook, checkHook));
+      return issue.issues.flatMap((issue2) => toDefaultIssues(issue2, path21, leafHook, checkHook));
     }
     default:
       return [{
-        path: path19,
+        path: path21,
         message: leafHook(issue)
       }];
   }
@@ -11862,7 +11969,7 @@ function makeFormatterDefault() {
   return (issue) => formatIssue(issue, "");
 }
 var defaultFormatter = /* @__PURE__ */ makeFormatterDefault();
-function formatIssue(issue, path19) {
+function formatIssue(issue, path21) {
   let message;
   switch (issue._tag) {
     case "Filter": {
@@ -11871,7 +11978,7 @@ function formatIssue(issue, path19) {
         message = annotated;
       } else {
         if (issue.issue._tag !== "InvalidValue") {
-          return formatIssue(issue.issue, path19);
+          return formatIssue(issue.issue, path21);
         }
         const expected = findExpected(issue.issue);
         message = expected === void 0 ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue);
@@ -11879,13 +11986,13 @@ function formatIssue(issue, path19) {
       break;
     }
     case "Encoding":
-      return formatIssue(issue.issue, path19);
+      return formatIssue(issue.issue, path21);
     case "Pointer":
-      return formatIssue(issue.issue, path19 + formatPath(issue.path));
+      return formatIssue(issue.issue, path21 + formatPath(issue.path));
     case "Composite":
     case "AnyOf": {
       if (issue._tag === "Composite" || issue.issues.length > 0) {
-        return issue.issues.map((issue2) => formatIssue(issue2, path19)).join("\n");
+        return issue.issues.map((issue2) => formatIssue(issue2, path21)).join("\n");
       }
       message = findMessage(issue) ?? getExpectedMessage(getExpected(issue.ast), issue);
       break;
@@ -11894,8 +12001,8 @@ function formatIssue(issue, path19) {
       message = defaultLeafHook(issue);
       break;
   }
-  return path19 ? `${message}
-  at ${path19}` : message;
+  return path21 ? `${message}
+  at ${path21}` : message;
 }
 function findMessage(issue) {
   if (issue._tag === "Pointer") return;
@@ -16316,10 +16423,10 @@ function makeReducer2(combiner2) {
 }
 
 // ../../node_modules/.bun/effect@4.0.0-rc.111/node_modules/effect/dist/internal/errors.js
-function errorWithPath(message, path19) {
-  if (path19.length > 0) {
+function errorWithPath(message, path21) {
+  if (path21.length > 0) {
     message += `
-  at ${formatPath(path19)}`;
+  at ${formatPath(path21)}`;
   }
   return new Error(message);
 }
@@ -16660,26 +16767,26 @@ function filterLayer(ast, checks, normalBase, terminalBase) {
   });
 }
 var memoized = /* @__PURE__ */ memoize((ast) => recur(ast, []));
-function recur(ast, path19) {
+function recur(ast, path21) {
   const annotation = resolve(ast)?.toArbitrary;
   if (annotation) {
-    const typeParameters = isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path19)) : [];
+    const typeParameters = isDeclaration(ast) ? ast.typeParameters.map((tp) => recur(tp, path21)) : [];
     const checks = collectChecks(ast.checks);
     const derive = (lazyNormal) => (fc, ctx, nextCtx, recursionStack) => normalizeDerivation(annotation(makeTypeParameters(typeParameters, fc, resetContext(ctx), recursionStack, lazyNormal))(fc, nextCtx), typeParameters.length > 0)[lazyNormal ? "terminal" : "arbitrary"];
     return filterLayer(ast, checks, derive(false), derive(true));
   }
   if (ast.checks) {
     const checks = collectChecks(ast.checks);
-    const lawc = recur(replaceChecks(ast, void 0), path19);
+    const lawc = recur(replaceChecks(ast, void 0), path21);
     return filterLayer(ast, checks, (fc, _ctx, nextCtx, recursionStack) => lawc(fc, nextCtx, recursionStack), (fc, _ctx, nextCtx, recursionStack) => lawc.terminal(fc, nextCtx, recursionStack));
   }
-  return base(ast, path19);
+  return base(ast, path21);
 }
-function base(ast, path19) {
+function base(ast, path21) {
   switch (ast._tag) {
     case "Never":
     case "Declaration":
-      throw errorWithPath(`Unsupported AST ${ast._tag}`, path19);
+      throw errorWithPath(`Unsupported AST ${ast._tag}`, path21);
     case "Null":
       return same((fc) => fc.constant(null));
     case "Void":
@@ -16716,20 +16823,20 @@ function base(ast, path19) {
     case "ObjectKeyword":
       return same((fc) => fc.oneof(fc.object(), fc.array(fc.anything())));
     case "Enum":
-      return recur(enumsToLiterals(ast), path19);
+      return recur(enumsToLiterals(ast), path21);
     case "TemplateLiteral": {
-      const parts = ast.parts.map((part, i) => recur(toEncoded(part), [...path19, i]));
+      const parts = ast.parts.map((part, i) => recur(toEncoded(part), [...path21, i]));
       return same((fc, ctx, recursionStack) => fc.tuple(...parts.map((part) => part(fc, finiteNumberContext(ctx), recursionStack))).map((segments) => segments.map((segment) => globalThis.String(segment)).join("")));
     }
     case "Arrays": {
       const elements = ast.elements.map((ast2, i) => ({
         ast: ast2,
-        arbitrary: recur(ast2, [...path19, i])
+        arbitrary: recur(ast2, [...path21, i])
       }));
       const len = ast.elements.length;
       const rest = ast.rest.map((ast2, i) => ({
         ast: ast2,
-        arbitrary: recur(ast2, [...path19, len + i])
+        arbitrary: recur(ast2, [...path21, len + i])
       }));
       const terminal = (fc, ctx, recursionStack) => {
         const reset = resetContext(ctx);
@@ -16829,12 +16936,12 @@ function base(ast, path19) {
     case "Objects": {
       const propertySignatures = ast.propertySignatures.map((ps) => ({
         ps,
-        arbitrary: recur(ps.type, [...path19, ps.name])
+        arbitrary: recur(ps.type, [...path21, ps.name])
       }));
       const indexSignatures = ast.indexSignatures.map((is3) => ({
         is: is3,
-        parameter: recur(is3.parameter, path19),
-        type: recur(is3.type, path19)
+        parameter: recur(is3.parameter, path21),
+        type: recur(is3.type, path21)
       }));
       const terminal = (fc, ctx, recursionStack) => {
         const reset = resetContext(ctx);
@@ -16937,7 +17044,7 @@ function base(ast, path19) {
       }, terminal);
     }
     case "Union": {
-      const types = ast.types.map((ast2) => recur(ast2, path19));
+      const types = ast.types.map((ast2) => recur(ast2, path21));
       const terminal = (fc, ctx, recursionStack) => oneOf(fc, types.map((type) => type.terminal(fc, ctx, recursionStack)).filter(isNotUndefined));
       return makeLazy((fc, ctx, recursionStack) => {
         const arbitraries = types.map((type) => type(fc, ctx, recursionStack));
@@ -16957,7 +17064,7 @@ function base(ast, path19) {
     case "Suspend": {
       const memo = arbitraryMemoMap.get(ast);
       if (memo) return memo;
-      const get5 = memoizeThunk(() => recur(ast.thunk(), path19));
+      const get5 = memoizeThunk(() => recur(ast.thunk(), path21));
       const out = makeLazy((fc, ctx, recursionStack) => {
         const recursion = getSuspendRecursion(fc, ast);
         const nextCtx = {
@@ -16967,7 +17074,7 @@ function base(ast, path19) {
         const nextStack = recursionStack.includes(ast) ? recursionStack : [...recursionStack, ast];
         const terminal = get5().terminal(fc, nextCtx, nextStack);
         if (terminal === void 0) {
-          throw errorWithPath("Unable to derive an arbitrary for a recursive schema without a finite generation path", path19);
+          throw errorWithPath("Unable to derive an arbitrary for a recursive schema without a finite generation path", path21);
         }
         return fc.oneof(recursion, terminal, fc.constant(null).chain(() => get5()(fc, nextCtx, nextStack)));
       }, (fc, ctx, recursionStack) => {
@@ -16990,10 +17097,10 @@ function base(ast, path19) {
 var toEquivalence = /* @__PURE__ */ memoize((ast) => {
   return recur2(ast, []);
 });
-function recur2(ast, path19) {
+function recur2(ast, path21) {
   const annotation = resolve(ast)?.["toEquivalence"];
   if (annotation) {
-    return annotation(isDeclaration(ast) ? ast.typeParameters.map((tp) => recur2(tp, path19)) : []);
+    return annotation(isDeclaration(ast) ? ast.typeParameters.map((tp) => recur2(tp, path21)) : []);
   }
   switch (ast._tag) {
     case "Never":
@@ -17016,9 +17123,9 @@ function recur2(ast, path19) {
     case "TemplateLiteral":
       return equals;
     case "Arrays": {
-      const elements = ast.elements.map((e, i) => recur2(e, [...path19, i]));
+      const elements = ast.elements.map((e, i) => recur2(e, [...path21, i]));
       const len = ast.elements.length;
-      const rest = ast.rest.map((r, i) => recur2(r, [...path19, len + i]));
+      const rest = ast.rest.map((r, i) => recur2(r, [...path21, len + i]));
       return make2((a, b) => {
         if (!Array.isArray(a) || !Array.isArray(b)) {
           return false;
@@ -17053,8 +17160,8 @@ function recur2(ast, path19) {
       if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
         return equals;
       }
-      const propertySignatures = ast.propertySignatures.map((ps) => recur2(ps.type, [...path19, ps.name]));
-      const indexSignatures = ast.indexSignatures.map((is3) => recur2(is3.type, path19));
+      const propertySignatures = ast.propertySignatures.map((ps) => recur2(ps.type, [...path21, ps.name]));
+      const indexSignatures = ast.indexSignatures.map((is3) => recur2(is3.type, path21));
       return make2((a, b) => {
         if (!isObject(a) || !isObject(b)) {
           return false;
@@ -17090,7 +17197,7 @@ function recur2(ast, path19) {
     }
     case "Union": {
       const types = toType(ast).types;
-      const compiled = new Map(types.map((candidate, i) => [candidate, [_is(candidate), recur2(ast.types[i], path19)]]));
+      const compiled = new Map(types.map((candidate, i) => [candidate, [_is(candidate), recur2(ast.types[i], path21)]]));
       return make2((a, b) => {
         const candidates = getCandidates(a, types);
         for (let i = 0; i < candidates.length; i++) {
@@ -17103,7 +17210,7 @@ function recur2(ast, path19) {
       });
     }
     case "Suspend": {
-      const get5 = memoizeThunk(() => recur2(ast.thunk(), path19));
+      const get5 = memoizeThunk(() => recur2(ast.thunk(), path21));
       return make2((a, b) => get5()(a, b));
     }
   }
@@ -17389,11 +17496,11 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     schemas,
     definitions
   };
-  function compileDefinition(key, path19) {
+  function compileDefinition(key, path21) {
     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}`, [...path19, "$ref"]);
+      throw errorWithPath(`Invalid reference ${key}`, [...path21, "$ref"]);
     }
     definitionStates.set(key, null);
     const representation = references[key];
@@ -17426,14 +17533,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, path19) {
-    return representation?.schemas?.map((schema, index2) => recur3(schema, [...path19, "schemas", index2])) ?? [];
+  function annotationSchemas(representation, path21) {
+    return representation?.schemas?.map((schema, index2) => recur3(schema, [...path21, "schemas", index2])) ?? [];
   }
-  function compileCheck(check2, type, path19) {
+  function compileCheck(check2, type, path21) {
     const annotations = check2.annotations;
     const callback2 = annotations?.toJsonSchema;
     if (callback2 !== void 0) {
-      const schemas2 = annotationSchemas(check2.representation, [...path19, "representation"]);
+      const schemas2 = annotationSchemas(check2.representation, [...path21, "representation"]);
       const fragment = callback2({
         type,
         schemas: schemas2
@@ -17447,7 +17554,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, [...path19, "checks", index2])).filter((child) => child !== void 0);
+    const children = check2.checks.map((child, index2) => compileCheck(child, type, [...path21, "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);
@@ -17458,16 +17565,16 @@ function compileJsonSchema(representations, rootPaths, references, options) {
       ...ordinary
     }];
   }
-  function recur3(representation, path19) {
+  function recur3(representation, path21) {
     if (representation._tag === "Reference") {
-      const canonical = compileDefinition(representation.$ref, path19);
+      const canonical = compileDefinition(representation.$ref, path21);
       return {
         $ref: `#/$defs/${escapeToken(canonical)}`
       };
     }
     const cached2 = compiledRepresentations.get(representation);
     if (cached2 !== void 0) return cached2;
-    let output = on(representation, path19);
+    let output = on(representation, path21);
     const ordinary = collectJsonSchemaAnnotations(representation.annotations, options);
     if (ordinary !== void 0) {
       output = {
@@ -17477,7 +17584,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, [...path19, "checks", index2]);
+      const check2 = compileCheck(representation.checks[index2], type, [...path21, "checks", index2]);
       if (check2 !== void 0) {
         output = appendJsonSchema(output, ...check2);
       }
@@ -17485,7 +17592,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     compiledRepresentations.set(representation, output);
     return output;
   }
-  function on(representation, path19) {
+  function on(representation, path21) {
     switch (representation._tag) {
       case "Any":
       case "Unknown":
@@ -17523,7 +17630,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         return {};
       }
       case "Suspend":
-        return recur3(representation.thunk, [...path19, "thunk"]);
+        return recur3(representation.thunk, [...path21, "thunk"]);
       case "Never":
         return {
           not: {}
@@ -17584,7 +17691,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         };
       case "Arrays": {
         if (representation.rest.length > 1) {
-          throw errorWithPath("Invalid schema representation document", [...path19, "rest"]);
+          throw errorWithPath("Invalid schema representation document", [...path21, "rest"]);
         }
         const out = {
           type: "array"
@@ -17592,7 +17699,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 = recur3(element.type, [...path19, "elements", index2, "type"]);
+          const compiled = recur3(element.type, [...path21, "elements", index2, "type"]);
           const annotations = collectJsonSchemaAnnotations(element.annotations, options);
           return annotations === void 0 ? compiled : appendJsonSchema(compiled, annotations);
         });
@@ -17605,7 +17712,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         }
         if (representation.rest.length === 1) {
           delete out.maxItems;
-          const rest = recur3(representation.rest[0], [...path19, "rest", 0]);
+          const rest = recur3(representation.rest[0], [...path21, "rest", 0]);
           if (Object.keys(rest).length > 0) out.items = rest;
           else delete out.items;
         }
@@ -17629,10 +17736,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", [...path19, "propertySignatures", index2, "name"]);
+            throw errorWithPath("Invalid schema representation document", [...path21, "propertySignatures", index2, "name"]);
           }
           const name = property.name;
-          const compiled = recur3(property.type, [...path19, "propertySignatures", index2, "type"]);
+          const compiled = recur3(property.type, [...path21, "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);
@@ -17643,9 +17750,9 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         const additionalProperties = [];
         for (let index2 = 0; index2 < representation.indexSignatures.length; index2++) {
           const signature = representation.indexSignatures[index2];
-          let type = recur3(signature.type, [...path19, "indexSignatures", index2, "type"]);
+          let type = recur3(signature.type, [...path21, "indexSignatures", index2, "type"]);
           if (Object.keys(type).length === 1 && "not" in type) type = false;
-          const patterns = getParameterPatterns(signature.parameter, [...path19, "indexSignatures", index2, "parameter"], /* @__PURE__ */ new Set());
+          const patterns = getParameterPatterns(signature.parameter, [...path21, "indexSignatures", index2, "parameter"], /* @__PURE__ */ new Set());
           if (patterns.length === 0) {
             additionalProperties.push(type);
           } else {
@@ -17675,7 +17782,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         return out;
       }
       case "Union": {
-        const types = representation.types.map((type, index2) => recur3(type, [...path19, "types", index2]));
+        const types = representation.types.map((type, index2) => recur3(type, [...path21, "types", index2]));
         if (types.length === 0) return {
           not: {}
         };
@@ -17691,25 +17798,25 @@ function compileJsonSchema(representations, rootPaths, references, options) {
       }
     }
   }
-  function getParameterPatterns(parameter, path19, seenReferences) {
+  function getParameterPatterns(parameter, path21, seenReferences) {
     switch (parameter._tag) {
       case "Reference": {
         if (!Object.hasOwn(references, parameter.$ref)) {
-          throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path19, "$ref"]);
+          throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path21, "$ref"]);
         }
-        compileDefinition(parameter.$ref, path19);
+        compileDefinition(parameter.$ref, path21);
         if (seenReferences.has(parameter.$ref)) return [];
         const next = new Set(seenReferences).add(parameter.$ref);
         return getParameterPatterns(references[parameter.$ref], ["references", parameter.$ref], next);
       }
       case "String":
-        return collectPatterns(recur3(parameter, path19));
+        return collectPatterns(recur3(parameter, path21));
       case "TemplateLiteral":
         return [`^${parameter.parts.map(getPartPattern).join("")}$`];
       case "Union":
-        return parameter.types.flatMap((type, index2) => getParameterPatterns(type, [...path19, "types", index2], seenReferences));
+        return parameter.types.flatMap((type, index2) => getParameterPatterns(type, [...path21, "types", index2], seenReferences));
       default:
-        throw errorWithPath("Invalid schema representation document", path19);
+        throw errorWithPath("Invalid schema representation document", path21);
     }
   }
 }
@@ -18094,25 +18201,25 @@ function get4(oldValue, newValue) {
   getLoop(oldValue, newValue, "", patches);
   return patches;
 }
-function getLoop(oldValue, newValue, path19, patches) {
+function getLoop(oldValue, newValue, path21, 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], `${path19}/${i}`, patches);
+      getLoop(oldValue[i], newValue[i], `${path21}/${i}`, patches);
     }
     for (let i = len1 - 1; i >= len2; i--) {
       patches.push({
         op: "remove",
-        path: `${path19}/${i}`
+        path: `${path21}/${i}`
       });
     }
     for (let i = len1; i < len2; i++) {
       patches.push({
         op: "add",
-        path: `${path19}/${i}`,
+        path: `${path21}/${i}`,
         value: newValue[i]
       });
     }
@@ -18123,7 +18230,7 @@ function getLoop(oldValue, newValue, path19, patches) {
     const keys22 = Object.keys(newValue);
     const allKeys = Array.from(/* @__PURE__ */ new Set([...keys1, ...keys22])).sort();
     for (const key of allKeys) {
-      const keyPath = `${path19}/${escapeToken(key)}`;
+      const keyPath = `${path21}/${escapeToken(key)}`;
       const hasKey1 = Object.hasOwn(oldValue, key);
       const hasKey2 = Object.hasOwn(newValue, key);
       if (hasKey1 && hasKey2) {
@@ -18145,7 +18252,7 @@ function getLoop(oldValue, newValue, path19, patches) {
   }
   patches.push({
     op: "replace",
-    path: path19,
+    path: path21,
     value: newValue
   });
 }
@@ -18295,12 +18402,12 @@ var PathNode = class {
   path;
   get;
   set;
-  constructor(path19) {
-    this.path = path19;
+  constructor(path21) {
+    this.path = path21;
     this.get = (s) => {
       let out = s;
-      for (let i = 0; i < path19.length; i++) {
-        out = out[path19[i]];
+      for (let i = 0; i < path21.length; i++) {
+        out = out[path21[i]];
       }
       return out;
     };
@@ -18308,12 +18415,12 @@ var PathNode = class {
       const out = cloneShallow(s);
       let current = out;
       let i = 0;
-      for (; i < path19.length - 1; i++) {
-        const key = path19[i];
+      for (; i < path21.length - 1; i++) {
+        const key = path21[i];
         assignProperty(current, key, cloneShallow(current[key]));
         current = current[key];
       }
-      assignProperty(current, path19[i], a);
+      assignProperty(current, path21[i], a);
       return out;
     };
   }
@@ -23170,82 +23277,12 @@ var ProviderEvent = Schema_exports.Struct({
   payload: Schema_exports.optional(Schema_exports.Unknown)
 });
 
-// ../../packages/contracts/src/filesystem.ts
-var FILESYSTEM_PATH_MAX_LENGTH = 512;
-var FilesystemBrowseInput = Schema_exports.Struct({
-  partialPath: TrimmedNonEmptyString.check(Schema_exports.isMaxLength(FILESYSTEM_PATH_MAX_LENGTH)),
-  cwd: Schema_exports.optional(TrimmedNonEmptyString.check(Schema_exports.isMaxLength(FILESYSTEM_PATH_MAX_LENGTH)))
-});
-var FilesystemBrowseEntry = Schema_exports.Struct({
-  name: TrimmedNonEmptyString,
-  fullPath: TrimmedNonEmptyString
-});
-var FilesystemBrowseResult = Schema_exports.Struct({
-  parentPath: TrimmedNonEmptyString,
-  entries: Schema_exports.Array(FilesystemBrowseEntry)
-});
-
-// ../../packages/contracts/src/editor.ts
-var EDITORS = [
-  { id: "cursor", label: "Cursor", commands: ["cursor"], supportsGoto: true },
-  { id: "vscode", label: "VS Code", commands: ["code"], supportsGoto: true },
-  {
-    id: "vscode-insiders",
-    label: "VS Code Insiders",
-    commands: ["code-insiders"],
-    supportsGoto: true
-  },
-  { id: "vscodium", label: "VSCodium", commands: ["codium"], supportsGoto: true },
-  { id: "zed", label: "Zed", commands: ["zed", "zeditor"], supportsGoto: false },
-  { id: "antigravity", label: "Antigravity", commands: ["agy"], supportsGoto: false },
-  { id: "file-manager", label: "File Manager", commands: null, supportsGoto: false }
-];
-var EditorId = Schema_exports.Literals(EDITORS.map((e) => e.id));
-var OpenInEditorInput = Schema_exports.Struct({
-  cwd: TrimmedNonEmptyString,
-  editor: EditorId
-});
-
-// ../../packages/contracts/src/runtime.ts
-var RuntimeConfigIssue = Schema_exports.Struct({
-  kind: TrimmedNonEmptyString,
-  message: TrimmedNonEmptyString
-});
-var RuntimeConfigIssues = Schema_exports.Array(RuntimeConfigIssue);
-var RuntimeProviderStatusState = Schema_exports.Literals(["ready", "warning", "error"]);
-var RuntimeProviderAuthStatus = Schema_exports.Literals([
-  "authenticated",
-  "unauthenticated",
-  "unknown"
-]);
-var RuntimeProviderStatus = Schema_exports.Struct({
-  provider: ProviderKind,
-  status: RuntimeProviderStatusState,
-  available: Schema_exports.Boolean,
-  authStatus: RuntimeProviderAuthStatus,
-  checkedAt: IsoDateTime,
-  message: Schema_exports.optional(TrimmedNonEmptyString)
-});
-var RuntimeProviderStatuses = Schema_exports.Array(RuntimeProviderStatus);
-var RuntimeConfig = Schema_exports.Struct({
-  cwd: TrimmedNonEmptyString,
-  issues: RuntimeConfigIssues,
-  providers: RuntimeProviderStatuses,
-  availableEditors: Schema_exports.Array(EditorId)
-});
-var RuntimeProviderUpdatedPayload = Schema_exports.Struct({
-  providers: RuntimeProviderStatuses
-});
-
-// ../../packages/contracts/src/rpc.ts
+// ../../packages/contracts/src/desktop/rpc-types.ts
 var RPC_METHODS = {
   filesystemBrowse: "filesystem.browse",
-  // Shell methods
   shellOpenInEditor: "shell.openInEditor",
-  // Runtime meta
   runtimeGetConfig: "runtime.getConfig",
   runtimeRefreshProviders: "runtime.refreshProviders",
-  // Desktop dashboard/runtime methods
   appStateGet: "appState.get",
   appStatePatch: "appState.patch",
   appSettingsGet: "appSettings.get",
@@ -23314,6 +23351,7 @@ var RPC_METHODS = {
   desktopLlmSetProviderEnabled: "desktopLlm.setProviderEnabled",
   desktopLlmSetRoutePublished: "desktopLlm.setRoutePublished",
   desktopLlmProbeRoute: "desktopLlm.probeRoute",
+  desktopLlmCreateGuidedProfile: "desktopLlm.createGuidedProfile",
   desktopLlmUpsertExternalProfile: "desktopLlm.upsertExternalProfile",
   desktopLlmDeleteExternalProfile: "desktopLlm.deleteExternalProfile",
   desktopLlmLaunchExternalProfile: "desktopLlm.launchExternalProfile",
@@ -23346,6 +23384,75 @@ var RPC_CHANNELS = {
   officialCodexActivityUpdated: "officialCodex.activityUpdated",
   officialCodexStatusUpdated: "officialCodex.statusUpdated"
 };
+
+// ../../packages/contracts/src/filesystem.ts
+var FILESYSTEM_PATH_MAX_LENGTH = 512;
+var FilesystemBrowseInput = Schema_exports.Struct({
+  partialPath: TrimmedNonEmptyString.check(Schema_exports.isMaxLength(FILESYSTEM_PATH_MAX_LENGTH)),
+  cwd: Schema_exports.optional(TrimmedNonEmptyString.check(Schema_exports.isMaxLength(FILESYSTEM_PATH_MAX_LENGTH)))
+});
+var FilesystemBrowseEntry = Schema_exports.Struct({
+  name: TrimmedNonEmptyString,
+  fullPath: TrimmedNonEmptyString
+});
+var FilesystemBrowseResult = Schema_exports.Struct({
+  parentPath: TrimmedNonEmptyString,
+  entries: Schema_exports.Array(FilesystemBrowseEntry)
+});
+
+// ../../packages/contracts/src/editor.ts
+var EDITORS = [
+  { id: "cursor", label: "Cursor", commands: ["cursor"], supportsGoto: true },
+  { id: "vscode", label: "VS Code", commands: ["code"], supportsGoto: true },
+  {
+    id: "vscode-insiders",
+    label: "VS Code Insiders",
+    commands: ["code-insiders"],
+    supportsGoto: true
+  },
+  { id: "vscodium", label: "VSCodium", commands: ["codium"], supportsGoto: true },
+  { id: "zed", label: "Zed", commands: ["zed", "zeditor"], supportsGoto: false },
+  { id: "antigravity", label: "Antigravity", commands: ["agy"], supportsGoto: false },
+  { id: "file-manager", label: "File Manager", commands: null, supportsGoto: false }
+];
+var EditorId = Schema_exports.Literals(EDITORS.map((e) => e.id));
+var OpenInEditorInput = Schema_exports.Struct({
+  cwd: TrimmedNonEmptyString,
+  editor: EditorId
+});
+
+// ../../packages/contracts/src/runtime.ts
+var RuntimeConfigIssue = Schema_exports.Struct({
+  kind: TrimmedNonEmptyString,
+  message: TrimmedNonEmptyString
+});
+var RuntimeConfigIssues = Schema_exports.Array(RuntimeConfigIssue);
+var RuntimeProviderStatusState = Schema_exports.Literals(["ready", "warning", "error"]);
+var RuntimeProviderAuthStatus = Schema_exports.Literals([
+  "authenticated",
+  "unauthenticated",
+  "unknown"
+]);
+var RuntimeProviderStatus = Schema_exports.Struct({
+  provider: ProviderKind,
+  status: RuntimeProviderStatusState,
+  available: Schema_exports.Boolean,
+  authStatus: RuntimeProviderAuthStatus,
+  checkedAt: IsoDateTime,
+  message: Schema_exports.optional(TrimmedNonEmptyString)
+});
+var RuntimeProviderStatuses = Schema_exports.Array(RuntimeProviderStatus);
+var RuntimeConfig = Schema_exports.Struct({
+  cwd: TrimmedNonEmptyString,
+  issues: RuntimeConfigIssues,
+  providers: RuntimeProviderStatuses,
+  availableEditors: Schema_exports.Array(EditorId)
+});
+var RuntimeProviderUpdatedPayload = Schema_exports.Struct({
+  providers: RuntimeProviderStatuses
+});
+
+// ../../packages/contracts/src/rpc.ts
 var tagRequestBody = (tag2, schema) => schema.mapFields(
   Struct_exports.assign({ _tag: Schema_exports.tag(tag2) }),
   // PreserveChecks is safe here. No existing schema should have checks depending on the tag
@@ -23449,6 +23556,7 @@ var DesktopRpcRequestBody = Schema_exports.Union([
         Schema_exports.Union([Schema_exports.Literal("manual"), Schema_exports.Literal("auto-roll")])
       ),
       carryDraft: Schema_exports.optional(Schema_exports.Boolean),
+      continueThreadId: Schema_exports.optional(Schema_exports.Union([Schema_exports.String, Schema_exports.Null])),
       forceAdopt: Schema_exports.optional(Schema_exports.Boolean),
       launchIfNotRunning: Schema_exports.optional(Schema_exports.Boolean),
       awaitCodexFollowUp: Schema_exports.optional(Schema_exports.Boolean)
@@ -23758,6 +23866,10 @@ var DesktopRpcRequestBody = Schema_exports.Union([
     RPC_METHODS.desktopLlmProbeRoute,
     Schema_exports.Struct({ publicSlug: TrimmedNonEmptyString })
   ),
+  tagRequestBody(
+    RPC_METHODS.desktopLlmCreateGuidedProfile,
+    Schema_exports.Struct({ input: Schema_exports.Unknown })
+  ),
   tagRequestBody(
     RPC_METHODS.desktopLlmUpsertExternalProfile,
     Schema_exports.Struct({ profile: Schema_exports.Unknown })
@@ -24223,7 +24335,7 @@ function authWritebackPaths(filePath) {
   };
 }
 function fingerprintAuth(content) {
-  return (0, import_node_crypto9.createHash)("sha256").update(content).digest("hex");
+  return (0, import_node_crypto10.createHash)("sha256").update(content).digest("hex");
 }
 async function readOptionalFile(filePath) {
   try {
@@ -24235,10 +24347,10 @@ async function readOptionalFile(filePath) {
   }
 }
 async function writeAtomicPath(filePath, content) {
-  const dir = import_node_path9.default.dirname(filePath);
-  const tempPath = import_node_path9.default.join(
+  const dir = import_node_path10.default.dirname(filePath);
+  const tempPath = import_node_path10.default.join(
     dir,
-    `.${import_node_path9.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto9.randomUUID)()}.tmp`
+    `.${import_node_path10.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto10.randomUUID)()}.tmp`
   );
   const handle = await import_node_fs6.promises.open(tempPath, "wx", 384);
   try {
@@ -24262,10 +24374,10 @@ async function writeAtomicPath(filePath, content) {
   }
 }
 async function installAuthFileIfAbsent(filePath, content) {
-  const dir = import_node_path9.default.dirname(filePath);
-  const tempPath = import_node_path9.default.join(
+  const dir = import_node_path10.default.dirname(filePath);
+  const tempPath = import_node_path10.default.join(
     dir,
-    `.${import_node_path9.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto9.randomUUID)()}.install`
+    `.${import_node_path10.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto10.randomUUID)()}.install`
   );
   const handle = await import_node_fs6.promises.open(tempPath, "wx", 384);
   try {
@@ -24336,7 +24448,7 @@ async function hasExternalOpenFileHandle(filePath) {
   }
   const lsofCommand = process.platform === "darwin" ? "/usr/sbin/lsof" : "lsof";
   return new Promise((resolve2) => {
-    const child = (0, import_node_child_process5.spawn)(lsofCommand, ["-F", "p", "--", filePath], {
+    const child = (0, import_node_child_process6.spawn)(lsofCommand, ["-F", "p", "--", filePath], {
       stdio: ["ignore", "pipe", "ignore"]
     });
     let output = "";
@@ -24479,7 +24591,7 @@ async function acquireCodexAuthFileSystemLock(filePath) {
   }
 }
 async function acquireCodexAuthFileLock(filePath) {
-  const queueKey = import_node_path9.default.resolve(filePath);
+  const queueKey = import_node_path10.default.resolve(filePath);
   const predecessor = authFileLockQueues.get(queueKey) ?? Promise.resolve();
   let finishTurn;
   const turn = new Promise((resolve2) => {
@@ -24512,7 +24624,7 @@ async function acquireCodexAuthFileLock(filePath) {
   }
 }
 async function acquireCodexAuthFileReadLock(filePath) {
-  const queueKey = import_node_path9.default.resolve(filePath);
+  const queueKey = import_node_path10.default.resolve(filePath);
   await (authFileLockQueues.get(queueKey) ?? Promise.resolve());
   const releaseReadLock = await acquireCrossProcessFileReadLock(filePath);
   if (!releaseReadLock) {
@@ -24686,9 +24798,9 @@ function parseRateLimitSnapshotFromRpcMessage(message) {
   return snapshot2;
 }
 function resolveRpcAuthPath(envOverride, authPath) {
-  return authPath ?? import_node_path9.default.join(
+  return authPath ?? import_node_path10.default.join(
     resolveCodexHomeDir({
-      codexHomePath: envOverride?.CODEX_HOME ?? (envOverride?.HOME ? import_node_path9.default.join(envOverride.HOME, ".codex") : void 0)
+      codexHomePath: envOverride?.CODEX_HOME ?? (envOverride?.HOME ? import_node_path10.default.join(envOverride.HOME, ".codex") : void 0)
     }),
     "auth.json"
   );
@@ -24696,8 +24808,8 @@ 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_path9.default.join(import_node_os3.default.tmpdir(), "codex-rpc-"));
-  const tempAuthPath = import_node_path9.default.join(tempHome, "auth.json");
+  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");
   let initialSourceAuth;
   try {
     const authLock = await acquireCodexAuthFileReadLock(sourceAuthPath);
@@ -24736,7 +24848,7 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
     ["-s", "read-only", "-a", "never", "app-server"],
     childEnv
   );
-  const child = (0, import_node_child_process5.spawn)(command.command, command.args, {
+  const child = (0, import_node_child_process6.spawn)(command.command, command.args, {
     stdio: ["pipe", "pipe", "pipe"],
     env: childEnv,
     shell: command.shell
@@ -24830,9 +24942,9 @@ 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_path9.default.join(import_node_os3.default.tmpdir(), "codex-activation-")
+    import_node_path10.default.join(import_node_os3.default.tmpdir(), "codex-activation-")
   );
-  const tempAuthPath = import_node_path9.default.join(tempHome, "auth.json");
+  const tempAuthPath = import_node_path10.default.join(tempHome, "auth.json");
   let initialSourceAuth;
   try {
     const authLock = await acquireCodexAuthFileReadLock(sourceAuthPath);
@@ -24862,14 +24974,14 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
   let configuredModel = null;
   try {
     const snapshot2 = await getCodexConfigSnapshot({
-      codexHomePath: import_node_path9.default.dirname(sourceAuthPath)
+      codexHomePath: import_node_path10.default.dirname(sourceAuthPath)
     });
     configuredModel = snapshot2.settings.model;
   } catch {
   }
   const activationModel = resolveActivationModel(configuredModel);
   await import_node_fs6.promises.writeFile(
-    import_node_path9.default.join(tempHome, "config.toml"),
+    import_node_path10.default.join(tempHome, "config.toml"),
     `model = ${JSON.stringify(activationModel)}
 `,
     "utf8"
@@ -24888,7 +25000,7 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
     ["-s", "read-only", "-a", "never", "app-server"],
     childEnv
   );
-  const child = (0, import_node_child_process5.spawn)(command.command, command.args, {
+  const child = (0, import_node_child_process6.spawn)(command.command, command.args, {
     stdio: ["pipe", "pipe", "pipe"],
     env: childEnv,
     shell: command.shell
@@ -25063,15 +25175,15 @@ async function activateResetWindowViaRpcIsolated(envOverride, options, sourceAut
 }
 
 // ../../packages/runtime-codex/src/codex/officialAppRestart.ts
-var import_node_child_process6 = require("child_process");
-var import_node_crypto10 = require("crypto");
+var import_node_child_process7 = require("child_process");
+var import_node_crypto11 = require("crypto");
 var import_node_fs8 = require("fs");
 var import_node_os4 = require("os");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/threadUsage.ts
 var import_node_fs7 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path11 = __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;
@@ -25093,7 +25205,7 @@ async function collectRolloutFiles(root) {
     const childVisits = [];
     for (const entry of entries3) {
       const entryName = String(entry.name);
-      const entryPath = import_node_path10.default.join(dir, entryName);
+      const entryPath = import_node_path11.default.join(dir, entryName);
       if (entry.isDirectory()) {
         childVisits.push(visit(entryPath));
         continue;
@@ -25118,7 +25230,7 @@ async function collectRolloutFilesStrict(root) {
     await Promise.all(
       entries3.map(async (entry) => {
         const entryName = String(entry.name);
-        const entryPath = import_node_path10.default.join(dir, entryName);
+        const entryPath = import_node_path11.default.join(dir, entryName);
         if (entry.isDirectory()) {
           await visit(entryPath);
         } else if (entry.isFile() && entryName.startsWith("rollout-") && entryName.endsWith(".jsonl")) {
@@ -25134,7 +25246,7 @@ async function readOfficialCodexRolloutActivityHeat(profileHome) {
   let latestUpdatedAtMs = null;
   try {
     for (const dirname of ROLLOUT_DIRS) {
-      const root = import_node_path10.default.join(profileHome, dirname);
+      const root = import_node_path11.default.join(profileHome, dirname);
       try {
         await import_node_fs7.promises.access(root);
       } catch (error) {
@@ -25166,10 +25278,10 @@ async function findRolloutFileByScan(profileHome, threadId) {
   let best = null;
   const variants = threadIdVariants(threadId);
   for (const dirname of ROLLOUT_DIRS) {
-    const root = import_node_path10.default.join(profileHome, dirname);
+    const root = import_node_path11.default.join(profileHome, dirname);
     const files = await collectRolloutFiles(root);
     for (const file of files) {
-      const basename = import_node_path10.default.basename(file);
+      const basename = import_node_path11.default.basename(file);
       if (!variants.some((variant) => basename.includes(variant))) {
         continue;
       }
@@ -25245,11 +25357,11 @@ function resolveRolloutPath(profileHome, rolloutPath) {
   if (!rolloutPath) {
     return null;
   }
-  return import_node_path10.default.isAbsolute(rolloutPath) ? rolloutPath : import_node_path10.default.join(profileHome, rolloutPath);
+  return import_node_path11.default.isAbsolute(rolloutPath) ? rolloutPath : import_node_path11.default.join(profileHome, rolloutPath);
 }
 async function collectSessionDatabasePaths(profileHome, sqliteHome = profileHome) {
   const paths = [];
-  const sqliteDir = import_node_path10.default.join(sqliteHome, "sqlite");
+  const sqliteDir = import_node_path11.default.join(sqliteHome, "sqlite");
   try {
     const entries3 = await import_node_fs7.promises.readdir(sqliteDir, {
       withFileTypes: true,
@@ -25260,20 +25372,20 @@ async function collectSessionDatabasePaths(profileHome, sqliteHome = profileHome
         continue;
       }
       const entryName = String(entry.name);
-      if (SQLITE_EXTENSIONS.has(import_node_path10.default.extname(entryName))) {
-        paths.push(import_node_path10.default.join(sqliteDir, entryName));
+      if (SQLITE_EXTENSIONS.has(import_node_path11.default.extname(entryName))) {
+        paths.push(import_node_path11.default.join(sqliteDir, entryName));
       }
     }
   } catch {
   }
   paths.sort((left, right) => {
-    const leftName = import_node_path10.default.basename(left);
-    const rightName = import_node_path10.default.basename(right);
+    const leftName = import_node_path11.default.basename(left);
+    const rightName = import_node_path11.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_path10.default.join(sqliteHome, "state_5.sqlite");
+  const legacy = import_node_path11.default.join(sqliteHome, "state_5.sqlite");
   if (!paths.includes(legacy)) {
     paths.push(legacy);
   }
@@ -25753,7 +25865,7 @@ function hashProfileKey(profileKey) {
   if (!profileKey) {
     return null;
   }
-  return (0, import_node_crypto10.createHash)("sha256").update(profileKey).digest("hex").slice(0, 12);
+  return (0, import_node_crypto11.createHash)("sha256").update(profileKey).digest("hex").slice(0, 12);
 }
 function sanitizeOfficialCodexOverlayActionTargetsForRenderer(targets) {
   const sanitized = [];
@@ -27434,7 +27546,7 @@ function createBridgeApplyQolExpression(settings) {
       if (customModelCount === 0) {
         const promo = document.createElement("p");
         promo.className = "codexuse-promo";
-        promo.textContent = "CodexUse can also run OpenRouter, DeepSeek, or a local model right here. Add one under Connect \u203A Model Providers.";
+        promo.textContent = "CodexUse can also run OpenRouter, DeepSeek, or a local model right here. Add one under Settings \u203A Model Providers.";
         section.appendChild(promo);
       }
       const divider = mount.firstElementChild?.nextElementSibling;
@@ -29365,7 +29477,7 @@ async function runCdpCommandSequence(debuggerUrl, commands, timeoutMs = CODEX_CD
   });
 }
 async function verifyCdpBindingRoundTrip(debuggerUrl) {
-  const nonce = (0, import_node_crypto10.randomUUID)();
+  const nonce = (0, import_node_crypto11.randomUUID)();
   const expression = `(() => {
     const binding = window[${JSON.stringify(CODEXUSE_BRIDGE_BINDING_NAME)}];
     if (typeof binding !== "function") return false;
@@ -29788,7 +29900,7 @@ async function startOfficialCodexBridgeActionListenerOnce(args2) {
   let closeNotified = false;
   let echoReceived = false;
   const requiredCommandIds = /* @__PURE__ */ new Set();
-  const echoId = (0, import_node_crypto10.randomUUID)();
+  const echoId = (0, import_node_crypto11.randomUUID)();
   const readyTimeout = setTimeout(() => {
     settleReady(false);
     try {
@@ -29862,7 +29974,7 @@ async function startOfficialCodexBridgeActionListenerOnce(args2) {
     }
   };
   bridgeActionListenerVerifiers.set(args2.debuggerUrl, async () => {
-    const id2 = (0, import_node_crypto10.randomUUID)();
+    const id2 = (0, import_node_crypto11.randomUUID)();
     return await new Promise((resolve2) => {
       const waiters = bridgeActionListenerHealthWaiters.get(args2.debuggerUrl) ?? /* @__PURE__ */ new Map();
       bridgeActionListenerHealthWaiters.set(args2.debuggerUrl, waiters);
@@ -29973,18 +30085,18 @@ async function startOfficialCodexBridgeActionListenerOnce(args2) {
         if (!requestId || !rememberBridgeActionId(requestId)) {
           return;
         }
-        const path19 = typeof payload.path === "string" ? payload.path.trim().slice(0, 64) : "";
+        const path21 = typeof payload.path === "string" ? payload.path.trim().slice(0, 64) : "";
         const requestHandler = officialCodexBridgeRequestHandler;
         void (async () => {
           let result2;
-          if (!path19) {
+          if (!path21) {
             result2 = { status: "failed", reason: "missing-path" };
           } else if (!requestHandler) {
             result2 = { status: "failed", reason: "no-request-handler" };
           } else {
             try {
               result2 = await requestHandler({
-                path: path19,
+                path: path21,
                 payload: payload.payload ?? null,
                 sourceProfileName: bridgeActionListenerProfiles.get(args2.debuggerUrl) ?? profileName
               });
@@ -30410,7 +30522,7 @@ async function recordOfficialCodexActivity(input) {
   };
   const finite2 = (value3, min4, max4) => typeof value3 === "number" && Number.isFinite(value3) ? Math.max(min4, Math.min(max4, value3)) : null;
   const entry = {
-    id: (0, import_node_crypto10.randomUUID)(),
+    id: (0, import_node_crypto11.randomUUID)(),
     at: now2.toISOString(),
     kind: input.kind,
     status: bounded(input.status, 80) ?? "unknown",
@@ -30480,7 +30592,7 @@ async function recordOfficialCodexActivity(input) {
 }
 function runCommand2(command, args2, timeoutMs = COMMAND_TIMEOUT_MS) {
   return new Promise((resolve2) => {
-    const child = (0, import_node_child_process6.spawn)(command, args2, {
+    const child = (0, import_node_child_process7.spawn)(command, args2, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -30559,7 +30671,7 @@ async function readProcessRows() {
   return rows;
 }
 function getMainExecutablePath(candidate) {
-  return import_node_path11.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
+  return import_node_path12.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
 }
 function isMainProcessRow(row, candidate) {
   return row.args.includes(getMainExecutablePath(candidate));
@@ -31404,12 +31516,12 @@ async function resolveOfficialCodexBridgeTarget(args2) {
 }
 var devToolsActivePortPaths = (appUserDataDir) => {
   const roots = appUserDataDir ? [appUserDataDir] : [
-    import_node_path11.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "OpenAI", "Codex"),
-    import_node_path11.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "Codex"),
-    import_node_path11.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "com.openai.codex"),
-    import_node_path11.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "com.openai.chat")
+    import_node_path12.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "OpenAI", "Codex"),
+    import_node_path12.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "Codex"),
+    import_node_path12.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "com.openai.codex"),
+    import_node_path12.default.join((0, import_node_os4.homedir)(), "Library", "Application Support", "com.openai.chat")
   ];
-  return roots.map((root) => import_node_path11.default.join(root, "DevToolsActivePort"));
+  return roots.map((root) => import_node_path12.default.join(root, "DevToolsActivePort"));
 };
 var readDevToolsActivePort = async (filePath) => {
   try {
@@ -31462,7 +31574,7 @@ async function openCodexWithProfileHome(candidate, profileHome, profileName, pre
   }
   const telemetryLabel = `codexuse-profile-${encodeURIComponent(profileName)}`;
   const launchHome = resolveCodexLaunchHome(profileHome);
-  const appUserDataDir = options.useDefaultUserData === true ? null : options.userDataDir ?? import_node_path11.default.join(profileHome, "codex-app-user-data");
+  const appUserDataDir = options.useDefaultUserData === true ? null : options.userDataDir ?? import_node_path12.default.join(profileHome, "codex-app-user-data");
   const sqliteHome = options.sqliteHome ?? profileHome;
   const activePortPaths = devToolsActivePortPaths(appUserDataDir);
   let child;
@@ -31470,7 +31582,7 @@ async function openCodexWithProfileHome(candidate, profileHome, profileName, pre
     if (appUserDataDir) {
       (0, import_node_fs8.mkdirSync)(appUserDataDir, { recursive: true });
     }
-    child = (0, import_node_child_process6.spawn)(
+    child = (0, import_node_child_process7.spawn)(
       "/usr/bin/open",
       [
         "-n",
@@ -31616,13 +31728,13 @@ async function openCodexWithProfileHome(candidate, profileHome, profileName, pre
   };
 }
 function resolveCodexLaunchHome(profileHome) {
-  if (Buffer.byteLength(import_node_path11.default.join(profileHome, "ipc", "ipc.sock")) >= 100) {
+  if (Buffer.byteLength(import_node_path12.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_path11.default.join(appPath, "Contents", "Info.plist");
+  const plistPath = import_node_path12.default.join(appPath, "Contents", "Info.plist");
   if (!(0, import_node_fs8.existsSync)(plistPath)) {
     return null;
   }
@@ -31642,18 +31754,18 @@ async function readBundleString(appPath, key) {
 }
 function addStandardOfficialCodexAppPaths(rawPaths) {
   for (const appName of OFFICIAL_CODEX_APP_NAMES) {
-    rawPaths.add(import_node_path11.default.join("/Applications", appName));
-    rawPaths.add(import_node_path11.default.join((0, import_node_os4.homedir)(), "Applications", appName));
+    rawPaths.add(import_node_path12.default.join("/Applications", appName));
+    rawPaths.add(import_node_path12.default.join((0, import_node_os4.homedir)(), "Applications", appName));
   }
 }
 function officialCodexAppPriority(appPath) {
-  const priority = OFFICIAL_CODEX_APP_NAMES.indexOf(import_node_path11.default.basename(appPath));
+  const priority = OFFICIAL_CODEX_APP_NAMES.indexOf(import_node_path12.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_fs8.existsSync)(appPath) || !OFFICIAL_CODEX_APP_NAMES.includes(import_node_path11.default.basename(appPath)) || !(0, import_node_fs8.existsSync)(import_node_path11.default.join(appPath, "Contents", "Resources", "codex"))) {
+    if (!(0, import_node_fs8.existsSync)(appPath) || !OFFICIAL_CODEX_APP_NAMES.includes(import_node_path12.default.basename(appPath)) || !(0, import_node_fs8.existsSync)(import_node_path12.default.join(appPath, "Contents", "Resources", "codex"))) {
       continue;
     }
     const bundleId = await readBundleString(appPath, "CFBundleIdentifier");
@@ -31664,7 +31776,7 @@ async function collectCodexAppCandidates(rawPaths) {
       appPath,
       bundleId,
       version: await readBundleString(appPath, "CFBundleShortVersionString"),
-      executableName: await readBundleString(appPath, "CFBundleExecutable") ?? import_node_path11.default.basename(appPath, ".app")
+      executableName: await readBundleString(appPath, "CFBundleExecutable") ?? import_node_path12.default.basename(appPath, ".app")
     });
   }
   return candidates.sort(
@@ -31673,7 +31785,7 @@ async function collectCodexAppCandidates(rawPaths) {
 }
 function getRunningCodexPidsFromRows(candidate, rows) {
   const pids = /* @__PURE__ */ new Set();
-  const appContentsRoot = `${import_node_path11.default.join(candidate.appPath, "Contents")}${import_node_path11.default.sep}`;
+  const appContentsRoot = `${import_node_path12.default.join(candidate.appPath, "Contents")}${import_node_path12.default.sep}`;
   for (const row of rows) {
     if (row.args.includes(appContentsRoot)) {
       pids.add(row.pid);
@@ -31683,7 +31795,7 @@ function getRunningCodexPidsFromRows(candidate, rows) {
 }
 function getRunningCodexMainPidsFromRows(candidate, rows) {
   const pids = /* @__PURE__ */ new Set();
-  const executablePath = import_node_path11.default.join(
+  const executablePath = import_node_path12.default.join(
     candidate.appPath,
     "Contents",
     "MacOS",
@@ -31721,7 +31833,7 @@ async function resolveCodexAppTarget() {
     mainPids: getRunningCodexMainPidsFromRows(candidate, rows)
   })).filter((entry) => entry.mainPids.length > 0);
   const explicit = explicitPath ? runningCandidates.find(
-    (entry) => import_node_path11.default.resolve(entry.candidate.appPath) === import_node_path11.default.resolve(explicitPath)
+    (entry) => import_node_path12.default.resolve(entry.candidate.appPath) === import_node_path12.default.resolve(explicitPath)
   ) : null;
   if (runningCandidates.length > 1) {
     return {
@@ -31762,10 +31874,10 @@ function resolveOfficialCodexThreadSqliteHome(profileHome) {
   return profileHome === SHARED_CODEX_HOME ? resolveCodexSqliteHomeDir(profileHome) : profileHome;
 }
 function sharedCodexLaunchOptions(useDefaultUserData, profileIdentity) {
-  const userDataDir = !useDefaultUserData && profileIdentity ? import_node_path11.default.join(
+  const userDataDir = !useDefaultUserData && profileIdentity ? import_node_path12.default.join(
     SHARED_CODEX_HOME,
     "codex-app-user-data",
-    (0, import_node_crypto10.createHash)("sha256").update(profileIdentity).digest("hex").slice(0, 16)
+    (0, import_node_crypto11.createHash)("sha256").update(profileIdentity).digest("hex").slice(0, 16)
   ) : void 0;
   return {
     useDefaultUserData,
@@ -31962,7 +32074,7 @@ function isSharedHomeMainProcessRow(row, candidate) {
     resolveProfileCodexHomesRoot(),
     resolveLegacyProfileCodexHomesRoot()
   ];
-  return isMainProcessRow(row, candidate) && managedRoots.every((root) => !row.args.includes(`${root}${import_node_path11.default.sep}`));
+  return isMainProcessRow(row, candidate) && managedRoots.every((root) => !row.args.includes(`${root}${import_node_path12.default.sep}`));
 }
 async function hydrateSharedHomeCdpWindow(rows, candidate) {
   const isRunningCandidate = async (value3) => {
@@ -34176,7 +34288,7 @@ async function attemptOfficialCodexManagedLiveLogin(args2) {
   }
 }
 async function applyOfficialCodexLiveAccountSwitchOnce(options = {}, takeoverTrace = {
-  operationId: (0, import_node_crypto10.randomUUID)(),
+  operationId: (0, import_node_crypto11.randomUUID)(),
   attempt: 1
 }) {
   let expectedWindowPreflight = options.expectedWindowPreflight;
@@ -35244,7 +35356,7 @@ async function applyOfficialCodexLiveAccountSwitchOnce(options = {}, takeoverTra
 }
 function applyOfficialCodexLiveAccountSwitch(options = {}) {
   return enqueueProfileAction("shared-window", async () => {
-    const operationId = (0, import_node_crypto10.randomUUID)();
+    const operationId = (0, import_node_crypto11.randomUUID)();
     let result2 = await applyOfficialCodexLiveAccountSwitchOnce(options, {
       operationId,
       attempt: 1
@@ -35969,16 +36081,16 @@ async function launchOfficialCodexProfileInstanceOnce(options) {
 }
 
 // ../../packages/runtime-app-state/src/app/profileHomeMutationCoordinator.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto12 = require("crypto");
 
 // ../../packages/runtime-app-state/src/app/processOwner.ts
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 function readProcessStartedAt(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) {
     return null;
   }
   try {
-    const output = (0, import_node_child_process7.execFileSync)("/bin/ps", ["-p", String(pid), "-o", "lstart="], {
+    const output = (0, import_node_child_process8.execFileSync)("/bin/ps", ["-p", String(pid), "-o", "lstart="], {
       encoding: "utf8",
       timeout: 2e3
     }).trim();
@@ -36007,12 +36119,12 @@ function isProcessEpochAlive(pid, expectedStartedAt) {
 // ../../packages/runtime-app-state/src/app/profileHomeMutationCoordinator.ts
 var PROFILE_HOME_MUTATION_TTL_MS = 10 * 60 * 1e3;
 var PROFILE_HOME_MUTATION_RENEW_MS = 30 * 1e3;
-var PROCESS_OWNER_ID = (0, import_node_crypto11.randomUUID)();
+var PROCESS_OWNER_ID = (0, import_node_crypto12.randomUUID)();
 var PROCESS_STARTED_AT = readProcessStartedAt(process.pid);
 var activeRenewals = /* @__PURE__ */ new Map();
 async function acquireProfileHomeMutationIntent(input) {
   const now2 = Date.now();
-  const operationId = (0, import_node_crypto11.randomUUID)();
+  const operationId = (0, import_node_crypto12.randomUUID)();
   const renewal = {
     timer: void 0,
     pending: Promise.resolve(),
@@ -36095,7 +36207,7 @@ async function releaseProfileHomeMutationIntent(homeId, operationId) {
 
 // ../../packages/runtime-profiles/src/profiles/rate-limit-cache.ts
 var import_node_fs9 = require("fs");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var memorySnapshots = /* @__PURE__ */ new Map();
 var persistedSnapshotWriteLock = Promise.resolve();
 var RATE_LIMIT_SNAPSHOT_CACHE_FILE = "rate-limit-snapshots.json";
@@ -36103,7 +36215,7 @@ function cloneSnapshot(snapshot2) {
   return JSON.parse(JSON.stringify(snapshot2));
 }
 function snapshotCachePath() {
-  return import_node_path12.default.join(getUserDataDir(), RATE_LIMIT_SNAPSHOT_CACHE_FILE);
+  return import_node_path13.default.join(getUserDataDir(), RATE_LIMIT_SNAPSHOT_CACHE_FILE);
 }
 async function loadPersistedSnapshots() {
   let raw;
@@ -36152,7 +36264,7 @@ async function writePersistedSnapshots(snapshots) {
     2
   );
   try {
-    await import_node_fs9.promises.mkdir(import_node_path12.default.dirname(filePath), { recursive: true });
+    await import_node_fs9.promises.mkdir(import_node_path13.default.dirname(filePath), { recursive: true });
     await import_node_fs9.promises.writeFile(tmpPath, `${payload}
 `, "utf8");
     await import_node_fs9.promises.rename(tmpPath, filePath);
@@ -36209,9 +36321,20 @@ async function pruneRateLimitSnapshots(allowedKeys) {
 
 // ../../packages/shared/src/core/profile-home-id.ts
 var PROFILE_HOME_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function isSafeProfileHomePathSegment(value3) {
+  if (typeof value3 !== "string" || value3 !== value3.trim()) {
+    return false;
+  }
+  return Boolean(
+    value3 && value3 !== "." && value3 !== ".." && value3.length <= 128 && !/[\\/]/.test(value3) && !Array.from(value3).some((character) => {
+      const code = character.charCodeAt(0);
+      return code < 32 || code === 127;
+    })
+  );
+}
 function normalizeProfileHomeId(value3) {
   const candidate = typeof value3 === "string" ? value3.trim() : "";
-  return candidate && candidate !== "." && candidate !== ".." && candidate.length <= 128 && PROFILE_HOME_ID_PATTERN.test(candidate) ? candidate : null;
+  return isSafeProfileHomePathSegment(candidate) && PROFILE_HOME_ID_PATTERN.test(candidate) ? candidate : null;
 }
 
 // ../../packages/runtime-profiles/src/profiles/profile-manager.ts
@@ -36223,7 +36346,7 @@ var AUTH_MUTATION_MANIFEST_NAME = ".codexuse-auth-transaction.json";
 var AUTH_MUTATION_BACKUP_NAME = ".codexuse-auth-transaction.backup";
 var AUTH_MUTATION_REPLACED_NAME = ".codexuse-auth-transaction.replaced";
 var PROFILE_HOME_MUTATION_MARKER_TTL_MS = 10 * 60 * 1e3;
-var PROCESS_OWNER_ID2 = (0, import_node_crypto12.randomUUID)();
+var PROCESS_OWNER_ID2 = (0, import_node_crypto13.randomUUID)();
 var PROCESS_STARTED_AT2 = readProcessStartedAt(process.pid);
 var globalAuthSwapLock = Promise.resolve();
 var profileOperationLocks = /* @__PURE__ */ new Map();
@@ -37033,7 +37156,14 @@ var ProfileManager = class {
     }
     await this.credentialsMigrationPromise;
   }
-  async migrateCredentialsToProfileHomes() {
+  migrateCredentialsToProfileHomes() {
+    return withCloudSyncTransaction(
+      getUserDataDir(),
+      "write",
+      () => this.migrateCredentialsToProfileHomesUnlocked()
+    );
+  }
+  async migrateCredentialsToProfileHomesUnlocked() {
     const source = await this.readProfilesStateSource();
     await this.reconcileProfileHomeLocationConflicts(source);
     const homeIdsByProfileName = /* @__PURE__ */ new Map();
@@ -37069,7 +37199,7 @@ var ProfileManager = class {
       let attempt = 0;
       let homeId;
       do {
-        homeId = `legacy-${(0, import_node_crypto12.createHash)("sha256").update(profileName).update("\0").update(String(attempt)).digest("hex").slice(0, 32)}`;
+        homeId = `legacy-${(0, import_node_crypto13.createHash)("sha256").update(profileName).update("\0").update(String(attempt)).digest("hex").slice(0, 32)}`;
         attempt += 1;
       } while (profileNamesByHomeId.has(homeId.toLowerCase()));
       homeIdsByProfileName.set(profileName, homeId);
@@ -37279,7 +37409,7 @@ var ProfileManager = class {
     const dir = import_path.default.dirname(filePath);
     const tempPath = import_path.default.join(
       dir,
-      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto12.randomUUID)()}.tmp`
+      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto13.randomUUID)()}.tmp`
     );
     await import_fs.promises.mkdir(dir, { recursive: true, mode: 448 });
     if (process.platform !== "win32") {
@@ -37566,7 +37696,7 @@ var ProfileManager = class {
     if (content === null) {
       return null;
     }
-    return (0, import_node_crypto12.createHash)("sha256").update(content).digest("hex");
+    return (0, import_node_crypto13.createHash)("sha256").update(content).digest("hex");
   }
   async readOptionalFile(filePath) {
     try {
@@ -37624,7 +37754,7 @@ var ProfileManager = class {
     const dir = import_path.default.dirname(filePath);
     const tempPath = import_path.default.join(
       dir,
-      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto12.randomUUID)()}.install`
+      `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto13.randomUUID)()}.install`
     );
     const handle = await import_fs.promises.open(tempPath, "wx", 384);
     try {
@@ -37709,29 +37839,31 @@ var ProfileManager = class {
     );
   }
   async withAuthMutationLock(task) {
-    const release = await this.acquireAuthMutationLock();
-    let result2;
-    let taskError = null;
-    let taskFailed = false;
-    try {
-      await this.recoverAuthMutationIfNeeded();
-      result2 = await task();
-    } catch (error) {
-      taskFailed = true;
-      taskError = error;
-    }
-    try {
-      await release();
-    } catch (releaseError) {
-      throw errorWithCause(
-        "Codex auth transaction lock could not be released.",
-        { taskError, releaseError }
-      );
-    }
-    if (taskFailed) {
-      throw taskError;
-    }
-    return result2;
+    return withCloudSyncTransaction(getUserDataDir(), "write", async () => {
+      const release = await this.acquireAuthMutationLock();
+      let result2;
+      let taskError = null;
+      let taskFailed = false;
+      try {
+        await this.recoverAuthMutationIfNeeded();
+        result2 = await task();
+      } catch (error) {
+        taskFailed = true;
+        taskError = error;
+      }
+      try {
+        await release();
+      } catch (releaseError) {
+        throw errorWithCause(
+          "Codex auth transaction lock could not be released.",
+          { taskError, releaseError }
+        );
+      }
+      if (taskFailed) {
+        throw taskError;
+      }
+      return result2;
+    });
   }
   async beginAuthMutation(operation, targetFingerprint) {
     const sourceRaw = await this.readOptionalFile(this.activeAuth);
@@ -37742,7 +37874,7 @@ var ProfileManager = class {
     });
     const manifest = {
       version: 1,
-      id: (0, import_node_crypto12.randomUUID)(),
+      id: (0, import_node_crypto13.randomUUID)(),
       operation,
       phase: "prepared",
       sourceFingerprint: this.fingerprintAuthContent(sourceRaw),
@@ -38414,7 +38546,14 @@ var ProfileManager = class {
   normalizeWorkspaceId(value3) {
     return typeof value3 === "string" && value3.trim().length > 0 ? value3.trim() : DEFAULT_WORKSPACE_ID;
   }
-  async persistProfileRecord(name, data, metadata, options) {
+  persistProfileRecord(name, data, metadata, options) {
+    return withCloudSyncTransaction(
+      getUserDataDir(),
+      "write",
+      () => this.persistProfileRecordUnlocked(name, data, metadata, options)
+    );
+  }
+  async persistProfileRecordUnlocked(name, data, metadata, options) {
     const resolvedName = this.normalizeProfileName(name);
     this.assertProfileHomeUsable(resolvedName);
     const initialMap = await this.readProfilesStateMap();
@@ -38464,7 +38603,7 @@ var ProfileManager = class {
     const displayName = typeof options?.displayName === "string" && options.displayName.trim().length > 0 ? options.displayName.trim() : existingRecord?.displayName ?? resolvedName;
     const record2 = {
       name: resolvedName,
-      homeId: existingRecord?.homeId ?? (options?.homeId ? this.normalizeProfileHomeId(options.homeId, resolvedName) : (0, import_node_crypto12.randomUUID)()),
+      homeId: existingRecord?.homeId ?? (options?.homeId ? this.normalizeProfileHomeId(options.homeId, resolvedName) : (0, import_node_crypto13.randomUUID)()),
       cloudHomeId: existingRecord?.cloudHomeId ?? null,
       displayName,
       data,
@@ -38569,7 +38708,7 @@ var ProfileManager = class {
     const safeName = record2.name.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 48) || "profile";
     const destination = import_path.default.join(
       trashRoot,
-      `CodexUse-${safeName}-${(0, import_node_crypto12.randomUUID)()}`
+      `CodexUse-${safeName}-${(0, import_node_crypto13.randomUUID)()}`
     );
     await import_fs.promises.rename(profileHome, destination);
     return destination;
@@ -38997,7 +39136,7 @@ var ProfileManager = class {
   async acquireProfileRuntimeLease(record2) {
     const leaseDir = this.getProfileRuntimeLeaseDir(record2.homeId);
     const deletingPath = (0, import_path2.join)(leaseDir, ".deleting");
-    const leaseId = (0, import_node_crypto12.randomUUID)();
+    const leaseId = (0, import_node_crypto13.randomUUID)();
     const leasePath = (0, import_path2.join)(leaseDir, `${leaseId}.json`);
     const backupPath = (0, import_path2.join)(leaseDir, `${leaseId}.auth.backup`);
     const releaseIntent = await this.acquireProfileHomeWriteIntent(record2);
@@ -39208,7 +39347,7 @@ var ProfileManager = class {
   async acquireProfileHomeMutationGuard(record2) {
     const leaseDir = this.getProfileRuntimeLeaseDir(record2.homeId);
     const deletingPath = (0, import_path2.join)(leaseDir, ".deleting");
-    const mutationId = (0, import_node_crypto12.randomUUID)();
+    const mutationId = (0, import_node_crypto13.randomUUID)();
     const mutationIntent = await acquireProfileHomeMutationIntent({
       homeId: record2.homeId,
       profileName: record2.name
@@ -40468,32 +40607,39 @@ var ProfileManager = class {
    */
   async exportProfilesForCloudSync() {
     await this.initialize();
-    const records = await this.listProfileRecords();
-    const exported = [];
-    for (const storedRecord of records) {
-      const record2 = await this.hydrateProfileRecordStrict(storedRecord);
-      exported.push({
-        name: record2.name,
-        homeId: record2.cloudHomeId ?? record2.homeId,
-        displayName: record2.displayName,
-        data: record2.data,
-        metadata: record2.metadata,
-        accountId: record2.accountId,
-        workspaceId: record2.workspaceId,
-        workspaceName: record2.workspaceName,
-        email: record2.email,
-        authMethod: record2.authMethod,
-        createdAt: record2.createdAt,
-        updatedAt: record2.updatedAt
-      });
-    }
-    return exported;
+    return withCloudSyncTransaction(getUserDataDir(), "write", async () => {
+      const records = await this.listProfileRecords();
+      const exported = [];
+      for (const storedRecord of records) {
+        const record2 = await this.hydrateProfileRecordStrict(storedRecord);
+        exported.push({
+          name: record2.name,
+          homeId: record2.cloudHomeId ?? record2.homeId,
+          displayName: record2.displayName,
+          data: record2.data,
+          metadata: record2.metadata,
+          accountId: record2.accountId,
+          workspaceId: record2.workspaceId,
+          workspaceName: record2.workspaceName,
+          email: record2.email,
+          authMethod: record2.authMethod,
+          createdAt: record2.createdAt,
+          updatedAt: record2.updatedAt
+        });
+      }
+      return exported;
+    });
   }
-  /**
-   * Replace local profiles with a full snapshot from cloud sync.
-   */
-  async replaceProfilesFromCloudSync(records) {
+  /** Replaces profiles, optionally deferring stale-home removal until commit. */
+  async replaceProfilesFromCloudSync(records, options = {}) {
     await this.initialize();
+    return withCloudSyncTransaction(
+      getUserDataDir(),
+      "write",
+      () => this.replaceProfilesFromCloudSyncUnlocked(records, options)
+    );
+  }
+  async replaceProfilesFromCloudSyncUnlocked(records, options) {
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const normalized = /* @__PURE__ */ new Map();
     const existingMap = await this.readProfilesStateMap();
@@ -40560,8 +40706,12 @@ var ProfileManager = class {
         }
         cloudRenamesByOldName.set(renamedExisting.name, name);
       }
-      const homeId = (0, import_node_crypto12.randomUUID)();
-      const cloudHomeId = remoteHomeId || existing?.cloudHomeId || existing?.homeId || renamedExisting?.cloudHomeId || renamedExisting?.homeId || (0, import_node_crypto12.randomUUID)();
+      const mappedHomeId = options.homeIdByProfileName?.[name];
+      if (mappedHomeId !== void 0 && !isSafeProfileHomePathSegment(mappedHomeId)) {
+        throw new Error(`Cloud Sync restore contains an invalid profile home id.`);
+      }
+      const homeId = mappedHomeId ?? (0, import_node_crypto13.randomUUID)();
+      const cloudHomeId = remoteHomeId || existing?.cloudHomeId || existing?.homeId || renamedExisting?.cloudHomeId || renamedExisting?.homeId || (0, import_node_crypto13.randomUUID)();
       const sourceRecord = renamedExisting ?? existing;
       if (sourceRecord) {
         sourceHomeIdByTargetHomeId.set(homeId, sourceRecord.homeId);
@@ -40599,6 +40749,9 @@ var ProfileManager = class {
     for (const record2 of normalized.values()) {
       nextMap[record2.name] = this.toStateRecord(record2);
     }
+    await options.onPreparedHomeIds?.(
+      Array.from(normalized.values(), (record2) => record2.homeId)
+    );
     const nextHomeIds = new Set(
       Array.from(normalized.values(), (record2) => record2.homeId)
     );
@@ -40612,6 +40765,7 @@ var ProfileManager = class {
     const preparedHomeIds = /* @__PURE__ */ new Set();
     let stateCommitted = false;
     let removed = 0;
+    let pendingStaleRemovals = [];
     const releaseAuthMutation = await this.acquireAuthMutationLock();
     let cloudSyncError = null;
     let cloudSyncFailed = false;
@@ -40647,18 +40801,21 @@ var ProfileManager = class {
           }
           homeExisted = false;
         }
-        if (homeExisted) {
+        const reusingExistingHome = options.homeIdByProfileName?.[record2.name] === record2.homeId;
+        if (homeExisted && !reusingExistingHome) {
           throw new Error(
             `Generated profile home '${record2.homeId}' already exists. Retry Cloud Sync.`
           );
         }
-        preparedHomeIds.add(record2.homeId);
+        if (!reusingExistingHome) {
+          preparedHomeIds.add(record2.homeId);
+        }
         const writtenAuth = JSON.stringify(
           this.convertToCodexFormat(record2.data),
           null,
           2
         );
-        const sourceHomeId = sourceHomeIdByTargetHomeId.get(record2.homeId);
+        const sourceHomeId = reusingExistingHome ? null : sourceHomeIdByTargetHomeId.get(record2.homeId);
         if (sourceHomeId) {
           const sourceHome = this.getProfileHomePath(sourceHomeId);
           let sourceHomeExists = true;
@@ -40720,16 +40877,13 @@ var ProfileManager = class {
       ).catch((error) => {
         logWarn("Failed to prune rate-limit snapshots after Cloud Sync:", error);
       });
-      for (const record2 of existingRecords.values()) {
-        if (nextHomeIds.has(record2.homeId)) {
-          continue;
-        }
-        try {
-          await this.removeProfileHome(record2, true);
-          removed += 1;
-        } catch (error) {
-          logWarn(`Failed to move stale profile '${record2.name}' to Trash after cloud sync:`, error);
-        }
+      const staleRecords = Array.from(existingRecords.values()).filter(
+        (record2) => !nextHomeIds.has(record2.homeId)
+      );
+      if (options.deferStaleHomeRemoval) {
+        pendingStaleRemovals = staleRecords;
+      } else {
+        removed = await this.removeStaleProfileHomes(staleRecords);
       }
     } catch (error) {
       cloudSyncFailed = true;
@@ -40783,9 +40937,61 @@ var ProfileManager = class {
     }
     return {
       imported: normalized.size,
-      removed
+      removed,
+      pendingStaleRemovals
     };
   }
+  /** Returns the physical home currently backing each profile. */
+  async getProfileHomeIdsByName() {
+    await this.initialize();
+    return withCloudSyncTransaction(getUserDataDir(), "write", async () => {
+      const stateMap = await this.readProfilesStateMap();
+      return Object.fromEntries(
+        Object.entries(stateMap).flatMap(([name, raw]) => {
+          const record2 = this.fromStateRecord(name, raw);
+          return record2?.homeId ? [[name, record2.homeId]] : [];
+        })
+      );
+    });
+  }
+  /** Permanently deletes unreferenced credential homes created by a failed pull. */
+  async deleteAbandonedPullProfileHomes(homeIds) {
+    if (homeIds.some((homeId) => normalizeProfileHomeId(homeId) !== homeId)) {
+      throw new Error("Cloud Sync cleanup contains an invalid profile home id.");
+    }
+    let deleted = 0;
+    for (const homeId of homeIds) {
+      try {
+        await import_fs.promises.rm(this.getProfileHomePath(homeId), {
+          recursive: true,
+          force: true
+        });
+        deleted += 1;
+      } catch (error) {
+        logWarn(
+          `Failed to delete the home an abandoned cloud pull created ('${homeId}'):`,
+          error
+        );
+      }
+    }
+    return deleted;
+  }
+  /** Moves stale user homes to Trash after every synced store commits. */
+  async removeStaleProfileHomes(records) {
+    let removed = 0;
+    for (const record2 of records) {
+      try {
+        await this.removeProfileHome(record2, true);
+        removed += 1;
+      } catch (error) {
+        logWarn(
+          `Failed to move stale profile '${record2.name}' to Trash after cloud sync:`,
+          error
+        );
+      }
+    }
+    return removed;
+  }
 };
 
 // ../../packages/runtime-profiles/src/profiles/managed-profile.ts
@@ -40998,8 +41204,8 @@ Flags:
   --take-control   Allow verified replacement of an unmanaged ChatGPT/Codex window
   --profile=NAME   Explicitly override a workspace binding for codexuse run
   --strict         Reject a --profile override that conflicts with a workspace binding
-  --runtime=NAME   Accounts Pool runtime store: desktop
-  --state-dir=PATH Override the runtime state dir for Accounts Pool inspection
+  --runtime=NAME   Account Pool runtime store: desktop
+  --state-dir=PATH Override the runtime state dir for Account Pool inspection
   --passphrase-stdin Read Cloud Sync passphrase from stdin
 Note: profile autoroll requires Pro or an active trial.
 Cloud Sync: set CODEXUSE_SYNC_PASSPHRASE or use --passphrase-stdin unless the passphrase is saved in Keychain.
@@ -41068,7 +41274,7 @@ function parseStringFlag(flags, name) {
 
 // src/commands/accountPool.ts
 var ACCOUNT_POOL_DOCUMENT = "desktop.account-pool.v2";
-var ACCOUNT_POOL_PRO_REQUIRED_MESSAGE = "Accounts Pool requires a Pro license or an active trial.";
+var ACCOUNT_POOL_PRO_REQUIRED_MESSAGE = "Account Pool requires a Pro license or an active trial.";
 var DESKTOP_RPC_STATE_DIR = "desktop-rpc";
 var ACCOUNT_POOL_STORE_VERSION = 3;
 var MAX_RESPONSE_IDS_PER_SESSION = 64;
@@ -41372,7 +41578,7 @@ function normalizeAccountPoolStore(value3) {
 }
 function normalizeAccountPoolStoreStrict(value3) {
   if (!value3 || typeof value3 !== "object" || Array.isArray(value3)) {
-    throw new Error("Accounts Pool store must be a JSON object.");
+    throw new Error("Account Pool store must be a JSON object.");
   }
   return normalizeAccountPoolStore(value3);
 }
@@ -41422,7 +41628,7 @@ function pruneStore(store) {
   return store;
 }
 function resolveAccountPoolDbPath(stateDir) {
-  return import_node_path13.default.join(stateDir, "state.sqlite");
+  return import_node_path14.default.join(stateDir, "state.sqlite");
 }
 async function readStore(stateDir) {
   const dbPath = resolveAccountPoolDbPath(stateDir);
@@ -41462,13 +41668,13 @@ async function listApiKeys(stateDir) {
   return Object.values(store.apiKeysById).filter((key) => key.revokedAt === null).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).map(accountPoolApiKeyView);
 }
 function hashToken(token) {
-  return (0, import_node_crypto13.createHash)("sha256").update(token).digest("hex");
+  return (0, import_node_crypto14.createHash)("sha256").update(token).digest("hex");
 }
 async function createApiKey(stateDir) {
-  const plaintextToken = `cux_pool_${(0, import_node_crypto13.randomBytes)(24).toString("hex")}`;
+  const plaintextToken = `cux_pool_${(0, import_node_crypto14.randomBytes)(24).toString("hex")}`;
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const keyRecord = {
-    id: (0, import_node_crypto13.randomUUID)(),
+    id: (0, import_node_crypto14.randomUUID)(),
     tokenHash: hashToken(plaintextToken),
     tokenPreview: `${plaintextToken.slice(0, 8)}...${plaintextToken.slice(-6)}`,
     createdAt: now2,
@@ -41523,9 +41729,9 @@ async function listSessions(stateDir) {
 }
 function resolveRuntimeStateDir(runtime, explicitStateDir) {
   if (explicitStateDir) {
-    return import_node_path13.default.resolve(explicitStateDir);
+    return import_node_path14.default.resolve(explicitStateDir);
   }
-  return import_node_path13.default.join(getUserDataDir(), DESKTOP_RPC_STATE_DIR);
+  return import_node_path14.default.join(getUserDataDir(), DESKTOP_RPC_STATE_DIR);
 }
 function resolveStateDir(flags) {
   const runtimeFlag = parseStringFlag(flags, "--runtime")?.trim().toLowerCase();
@@ -41685,7 +41891,7 @@ async function handleStatus(flags) {
   if (baseUrl) {
     console.log(`Base URL: ${baseUrl}`);
   } else {
-    console.log("Base URL: check the running desktop app for the current Accounts Pool URL.");
+    console.log("Base URL: check the running desktop app for the current Account Pool URL.");
   }
   printStringList("Selected profiles", selectedProfiles);
   if (missingSelectedProfiles.length > 0) {
@@ -41704,7 +41910,7 @@ async function handleEnable() {
     accountPoolEnableExistingMigrationApplied: true,
     accountPoolEnabled: true
   }));
-  console.log(`Accounts Pool ${result2.settings.accountPoolEnabled ? "enabled" : "disabled"}.`);
+  console.log(`Account Pool ${result2.settings.accountPoolEnabled ? "enabled" : "disabled"}.`);
 }
 async function handleDisable() {
   const result2 = await updateSettings((current) => ({
@@ -41712,7 +41918,7 @@ async function handleDisable() {
     accountPoolEnableExistingMigrationApplied: true,
     accountPoolEnabled: false
   }));
-  console.log(`Accounts Pool ${result2.settings.accountPoolEnabled ? "enabled" : "disabled"}.`);
+  console.log(`Account Pool ${result2.settings.accountPoolEnabled ? "enabled" : "disabled"}.`);
 }
 async function handleRouting(params) {
   const value3 = parseRoutingStrategy(params[1]);
@@ -41723,7 +41929,7 @@ async function handleRouting(params) {
     ...current,
     accountPoolRoutingStrategy: value3
   }));
-  console.log(`Accounts Pool routing set to ${formatRoutingStrategy(result2.settings.accountPoolRoutingStrategy)}.`);
+  console.log(`Account Pool routing set to ${formatRoutingStrategy(result2.settings.accountPoolRoutingStrategy)}.`);
 }
 async function handleProfiles(params) {
   const action = params[1];
@@ -41783,10 +41989,10 @@ async function handleProfiles(params) {
     };
   });
   if (result2.settings.accountPoolProfilePool.length === 0) {
-    console.log("Accounts Pool now uses all saved profiles.");
+    console.log("Account Pool now uses all saved profiles.");
     return;
   }
-  printStringList("Accounts Pool selected profiles", result2.settings.accountPoolProfilePool);
+  printStringList("Account Pool selected profiles", result2.settings.accountPoolProfilePool);
 }
 async function handleArraySetting(input) {
   const action = input.params[1];
@@ -41835,7 +42041,7 @@ async function handleKeys(params, flags) {
   if (!action || action === "list") {
     const apiKeys = await listApiKeys(stateDir);
     if (apiKeys.length === 0) {
-      console.log("No active Accounts Pool API keys.");
+      console.log("No active Account Pool API keys.");
       return;
     }
     for (const apiKey of apiKeys) {
@@ -41855,7 +42061,7 @@ async function handleKeys(params, flags) {
       if (baseUrl) {
         console.log(`Base URL: ${baseUrl}`);
       } else {
-        console.log("Base URL: use the current Accounts Pool URL shown by the running desktop app.");
+        console.log("Base URL: use the current Account Pool URL shown by the running desktop app.");
       }
       console.log("This key only works for the selected runtime state dir.");
       console.log("Store this token now. The plaintext value is only shown once.");
@@ -41868,7 +42074,7 @@ async function handleKeys(params, flags) {
       }
       const removed = await revokeApiKey(stateDir, id2);
       if (!removed) {
-        throw new Error(`No Accounts Pool API key found for id ${id2}.`);
+        throw new Error(`No Account Pool API key found for id ${id2}.`);
       }
       console.log(`Revoked key: ${id2}`);
       return;
@@ -41897,7 +42103,7 @@ async function handleQuickstart(flags) {
   const { runtime, stateDir } = resolveStateDir(flags);
   const summary = await readAccountPoolRuntimeSummary({ runtime, stateDir });
   const baseUrl = summary.baseUrl ?? "<shown-in-desktop-app>";
-  console.log("Accounts Pool quickstart");
+  console.log("Account Pool quickstart");
   console.log(`Runtime: ${summary.runtime}`);
   console.log(`Enabled: ${summary.enabled ? "yes" : "no"}`);
   console.log(`Access: ${summary.hasAccountPoolAccess ? "yes" : "no"}`);
@@ -41973,7 +42179,7 @@ async function handleAccountPoolCommand(args2, version) {
 }
 
 // src/commands/codex.ts
-var import_node_child_process9 = require("child_process");
+var import_node_child_process10 = require("child_process");
 var import_node_os6 = __toESM(require("os"));
 
 // ../../packages/runtime-profiles/src/profiles/rate-limit-notifier.ts
@@ -42094,9 +42300,9 @@ async function assertProfileAccessAllowed(profileManager, profileName) {
 
 // ../../packages/runtime-app-state/src/app/workspaceBindings.ts
 var import_node_fs10 = require("fs");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 async function canonicalizeWorkspacePath(input, options = {}) {
-  const resolved = import_node_path14.default.resolve(input || process.cwd());
+  const resolved = import_node_path15.default.resolve(input || process.cwd());
   try {
     const canonical = await import_node_fs10.promises.realpath(resolved);
     if (options.requireDirectory !== false) {
@@ -42105,10 +42311,10 @@ async function canonicalizeWorkspacePath(input, options = {}) {
         throw new Error(`Workspace path is not a directory: ${resolved}`);
       }
     }
-    return import_node_path14.default.normalize(canonical);
+    return import_node_path15.default.normalize(canonical);
   } catch (error) {
     if (options.requireDirectory === false) {
-      return import_node_path14.default.normalize(resolved);
+      return import_node_path15.default.normalize(resolved);
     }
     const message = error instanceof Error ? error.message : String(error);
     const symptom = new Error(
@@ -42175,7 +42381,7 @@ async function resolveWorkspaceProfileBinding(requestedPath) {
         inherited: candidate !== canonical
       };
     }
-    const parent = import_node_path14.default.dirname(candidate);
+    const parent = import_node_path15.default.dirname(candidate);
     if (parent === candidate) {
       return null;
     }
@@ -42184,13 +42390,13 @@ async function resolveWorkspaceProfileBinding(requestedPath) {
 }
 
 // src/platform/codexCli.ts
-var import_node_child_process8 = require("child_process");
+var import_node_child_process9 = require("child_process");
 var import_node_fs11 = require("fs");
-var import_node_path15 = __toESM(require("path"));
+var import_node_path16 = __toESM(require("path"));
 var ENV_HINTS2 = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
 function fileExists2(candidate) {
   if (!candidate) return null;
-  const resolved = import_node_path15.default.resolve(candidate);
+  const resolved = import_node_path16.default.resolve(candidate);
   try {
     const stat2 = (0, import_node_fs11.statSync)(resolved);
     if (stat2.isFile()) return resolved;
@@ -42210,9 +42416,9 @@ function resolveFromEnv() {
 }
 function resolveFromPath() {
   const pathValue = process.env.PATH ?? "";
-  const entries3 = pathValue.split(import_node_path15.default.delimiter).filter(Boolean);
+  const entries3 = pathValue.split(import_node_path16.default.delimiter).filter(Boolean);
   for (const entry of entries3) {
-    const candidate = fileExists2(import_node_path15.default.join(entry, "codex"));
+    const candidate = fileExists2(import_node_path16.default.join(entry, "codex"));
     if (candidate) return candidate;
   }
   return null;
@@ -42256,7 +42462,7 @@ async function runCodexLogin(mode, envOverrides = {}) {
   const resolvedMode = resolveLoginMode(mode ?? null);
   const loginArgs = resolvedMode === "device" ? ["login", "--device-auth"] : ["login"];
   const { command, args: args2, shell } = buildCodexCommand2(codexPath, loginArgs);
-  const child = (0, import_node_child_process8.spawn)(command, args2, {
+  const child = (0, import_node_child_process9.spawn)(command, args2, {
     stdio: "inherit",
     env: { ...process.env, ...envOverrides },
     shell
@@ -42325,7 +42531,7 @@ function compareCandidates(left, right) {
 async function runCommand3(codexPath, args2, timeoutMs) {
   const command = buildCodexCommand2(codexPath, args2);
   return new Promise((resolve2) => {
-    const child = (0, import_node_child_process9.spawn)(command.command, command.args, {
+    const child = (0, import_node_child_process10.spawn)(command.command, command.args, {
       env: process.env,
       shell: command.shell,
       stdio: ["ignore", "pipe", "pipe"]
@@ -42405,7 +42611,7 @@ async function runCodexWithProfile(manager, profileName, codexArgs) {
   });
   const command = buildCodexCommand2(codexPath, codexArgs);
   try {
-    const child = (0, import_node_child_process9.spawn)(command.command, command.args, {
+    const child = (0, import_node_child_process10.spawn)(command.command, command.args, {
       env: runtime.env,
       shell: command.shell,
       stdio: "inherit"
@@ -42467,7 +42673,7 @@ async function handleDoctorCommand(args2) {
     console.log(`Usage:
   codexuse doctor
 
-Checks Codex CLI, auth, saved profiles, license, and Accounts Pool readiness.`);
+Checks Codex CLI, auth, saved profiles, license, and Account Pool readiness.`);
     return;
   }
   const manager = new ProfileManager();
@@ -42495,10 +42701,10 @@ Checks Codex CLI, auth, saved profiles, license, and Accounts Pool readiness.`);
   console.log(`License: ${license ? `${license.tier} (${license.state})` : "unknown"}`);
   if (accountPool) {
     console.log(
-      `Accounts Pool: ${accountPool.enabled ? "on" : "off"} | keys ${accountPool.activeApiKeyCount} | sessions ${accountPool.activeSessionCount}`
+      `Account Pool: ${accountPool.enabled ? "on" : "off"} | keys ${accountPool.activeApiKeyCount} | sessions ${accountPool.activeSessionCount}`
     );
   } else {
-    console.log("Accounts Pool: unknown");
+    console.log("Account Pool: unknown");
   }
   const fixes = [];
   if (!codexPath) {
@@ -42653,15 +42859,15 @@ async function handleLicense(args2, version) {
 // src/commands/profile.ts
 var import_node_fs13 = require("fs");
 var import_node_os7 = __toESM(require("os"));
-var import_node_path17 = __toESM(require("path"));
+var import_node_path18 = __toESM(require("path"));
 
 // ../../packages/runtime-app-state/src/app/officialCodexSwitchCoordinator.ts
-var import_node_crypto14 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var import_node_fs12 = require("fs");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_path17 = __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_crypto14.randomUUID)();
+var PROCESS_OWNER_ID3 = (0, import_node_crypto15.randomUUID)();
 var PROCESS_STARTED_AT3 = readProcessStartedAt(process.pid);
 var localIntentDepth = /* @__PURE__ */ new Map();
 var pendingLocalIntentAcquisitions = /* @__PURE__ */ new Map();
@@ -42671,7 +42877,7 @@ function nextSwitchIntentGeneration(current) {
 }
 async function acquireOfficialCodexSwitchIntent(input) {
   const now2 = Date.now();
-  const operationId = input.operationId?.trim() || (0, import_node_crypto14.randomUUID)();
+  const operationId = input.operationId?.trim() || (0, import_node_crypto15.randomUUID)();
   const targetProfileName = input.targetProfileName.trim();
   if (!targetProfileName) {
     throw new Error("Profile name is required");
@@ -42802,6 +43008,191 @@ async function releaseOfficialCodexSwitchIntent(operationId) {
   }
 }
 
+// ../../packages/shared/src/core/errors.ts
+var ANSI_PATTERN = /\u001B\[[0-9;]*m/g;
+function stripAnsi(value3) {
+  return value3.replace(ANSI_PATTERN, "");
+}
+function normalizeWhitespace(value3) {
+  return value3.replace(/\s+/g, " ").trim();
+}
+function compactErrorText(value3, maxLength = 220) {
+  if (!value3) {
+    return "";
+  }
+  const cleaned = normalizeWhitespace(stripAnsi(String(value3)));
+  if (!cleaned) {
+    return "";
+  }
+  if (cleaned.length <= maxLength) {
+    return cleaned;
+  }
+  return `${cleaned.slice(0, maxLength).trimEnd()}\u2026`;
+}
+function createErrorReferenceId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`.toUpperCase();
+}
+function serializeUnknownError(value3) {
+  if (typeof value3 === "string") {
+    return value3;
+  }
+  if (value3 instanceof Error) {
+    return value3.stack ?? value3.message;
+  }
+  try {
+    return JSON.stringify(value3);
+  } catch {
+    return String(value3);
+  }
+}
+function extractRawMessage(error) {
+  if (error === null || typeof error === "undefined") {
+    return "";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function normalizeRawMessage(rawMessage) {
+  let cleaned = normalizeWhitespace(stripAnsi(rawMessage));
+  if (!cleaned) {
+    return "";
+  }
+  if (cleaned.startsWith("Error invoking remote method")) {
+    cleaned = cleaned.replace(/^Error invoking remote method '[^']+': Error: /, "");
+  }
+  if (cleaned.toLowerCase().includes("openai codex") && cleaned.toLowerCase().includes("workdir:")) {
+    const parts = cleaned.split(/error:/i);
+    if (parts.length > 1) {
+      return parts[parts.length - 1]?.trim() ?? cleaned;
+    }
+  }
+  return cleaned;
+}
+function resolveCategory(cleaned, options) {
+  const lower = cleaned.toLowerCase();
+  if (options.notFoundFallback && (lower.includes("enoent") || lower.includes("not found"))) {
+    return {
+      code: "ERR_NOT_FOUND",
+      title: "We couldn't find that item",
+      message: options.notFoundFallback,
+      recovery: "Check the path or selection, then try again.",
+      retryable: true
+    };
+  }
+  if (lower.includes("rate limit") || lower.includes("quota exceeded") || lower.includes("too many requests") || lower.includes("429")) {
+    return {
+      code: "ERR_RATE_LIMIT",
+      title: "Rate limit reached",
+      message: "The provider is rate limited right now.",
+      recovery: "Wait a moment, switch profiles, or try again.",
+      retryable: true
+    };
+  }
+  if (lower.includes("timeout") || lower.includes("timed out")) {
+    return {
+      code: "ERR_TIMEOUT",
+      title: "Request timed out",
+      message: "The operation took too long to finish.",
+      recovery: "Check the connection and try again.",
+      retryable: true
+    };
+  }
+  if (lower.includes("network") || lower.includes("econn") || lower.includes("networkerror") || lower.includes("connection refused") || lower.includes("socket hang up")) {
+    return {
+      code: "ERR_NETWORK",
+      title: "Can't reach the service",
+      message: "CodexUse couldn't connect to the required service.",
+      recovery: "Check your internet or local server connection, then retry.",
+      retryable: true
+    };
+  }
+  if (lower.includes("token_invalidated") || lower.includes("session invalidated") || lower.includes("session expired") || lower.includes("refresh token") || lower.includes("unauthorized") || lower.includes("401")) {
+    return {
+      code: "ERR_AUTH",
+      title: "Sign-in expired",
+      message: "This account needs to sign in again.",
+      recovery: "Reconnect the profile, then retry the action.",
+      retryable: true
+    };
+  }
+  if (lower.includes("permission") || lower.includes("eacces") || lower.includes("operation not permitted")) {
+    return {
+      code: "ERR_PERMISSION",
+      title: "Permission denied",
+      message: "CodexUse doesn't have permission to do that.",
+      recovery: "Check the file permissions or restart the app and try again.",
+      retryable: true
+    };
+  }
+  if (lower.includes("enospc") || lower.includes("disk full") || lower.includes("no space left")) {
+    return {
+      code: "ERR_DISK_FULL",
+      title: "Disk is full",
+      message: "CodexUse couldn't save data because the disk is full.",
+      recovery: "Free up disk space, then try again.",
+      retryable: true
+    };
+  }
+  if (lower.includes("codex cli") || lower.includes("command not found") || lower.includes("spawn codex") || lower.includes("could not find codex") || lower.includes("enoent") && (lower.includes("@openai/codex") || lower.includes("codex-darwin-") || lower.includes("/vendor/") || lower.includes("\\vendor\\")) || lower.includes("missing optional dependency")) {
+    return {
+      code: "ERR_CLI_UNAVAILABLE",
+      title: "Codex CLI unavailable",
+      message: "CodexUse couldn't start the Codex CLI.",
+      recovery: "Run npm install -g @openai/codex@latest --include=optional --force in Terminal, then try again.",
+      retryable: true
+    };
+  }
+  if (lower.includes("provider") || lower.includes("model") || lower.includes("openai") || lower.includes("anthropic")) {
+    return {
+      code: "ERR_PROVIDER",
+      title: "Provider request failed",
+      message: "The AI provider rejected or failed the request.",
+      recovery: "Try again, or switch the active profile or model.",
+      retryable: true
+    };
+  }
+  return {
+    code: "ERR_UNKNOWN",
+    title: "That did not work",
+    message: options.fallback,
+    recovery: "Try again. If it keeps happening, report the error with the reference below.",
+    retryable: true
+  };
+}
+function resolveUserFacingError(error, options = {}) {
+  const fallback = options.fallback ?? "That action did not complete.";
+  const rawMessage = extractRawMessage(error);
+  const cleaned = normalizeRawMessage(rawMessage);
+  const category = resolveCategory(cleaned, {
+    fallback,
+    ...options.notFoundFallback ? { notFoundFallback: options.notFoundFallback } : {}
+  });
+  return {
+    ...category,
+    referenceId: createErrorReferenceId(),
+    technicalMessage: compactErrorText(cleaned || rawMessage || fallback, 400),
+    technicalDetails: compactErrorText(serializeUnknownError(error), 4e3)
+  };
+}
+function formatUserFacingError(error, options = {}) {
+  const info = resolveUserFacingError(error, options);
+  const maxLength = typeof options.maxLength === "number" ? options.maxLength : 220;
+  const withRecovery = info.recovery && !/try again/i.test(info.message) ? `${info.message} ${info.recovery}` : info.message;
+  if (withRecovery.length <= maxLength) {
+    return withRecovery;
+  }
+  let cleaned = info.message;
+  if (cleaned.length > maxLength) {
+    cleaned = `${cleaned.slice(0, maxLength).trimEnd()}\u2026`;
+  }
+  return cleaned;
+}
+
 // ../../packages/runtime-profiles/src/profiles/official-codex-profile-switch.ts
 function safeReason(error, fallback) {
   const message = error instanceof Error ? error.message : "";
@@ -43165,7 +43556,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_fs13.promises.mkdtemp(import_node_path17.default.join(import_node_os7.default.tmpdir(), "codexuse-cli-login-"));
+  const home = await import_node_fs13.promises.mkdtemp(import_node_path18.default.join(import_node_os7.default.tmpdir(), "codexuse-cli-login-"));
   try {
     await runCodexLogin(mode, {
       HOME: home,
@@ -43173,7 +43564,7 @@ async function withIsolatedCodexLogin(mode, action) {
       CODEX_SQLITE_HOME: home,
       ELECTRON_RUN_AS_NODE: "1"
     });
-    return await action(import_node_path17.default.join(home, "auth.json"));
+    return await action(import_node_path18.default.join(home, "auth.json"));
   } finally {
     await import_node_fs13.promises.rm(home, { recursive: true, force: true }).catch(() => void 0);
   }
@@ -44691,9 +45082,53 @@ async function pushRemoteSnapshot(access, snapshot2, options) {
   };
 }
 
+// ../../packages/runtime-profiles/src/cloud-sync/journal.ts
+var import_node_fs14 = require("fs");
+var import_node_crypto16 = require("crypto");
+var import_node_path19 = __toESM(require("path"), 1);
+var JOURNAL_FILENAME = "cloud-sync-pull.journal.json";
+function getCloudSyncJournalPath() {
+  return import_node_path19.default.join(getUserDataDir(), JOURNAL_FILENAME);
+}
+async function syncDirectory(dir) {
+  const directory = await import_node_fs14.promises.open(dir, "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}
+async function writeCloudSyncJournal(journal) {
+  const target = getCloudSyncJournalPath();
+  const dir = import_node_path19.default.dirname(target);
+  await import_node_fs14.promises.mkdir(dir, { recursive: true, mode: 448 });
+  await import_node_fs14.promises.chmod(dir, 448);
+  const staging = `${target}.tmp-${process.pid}-${(0, import_node_crypto16.randomUUID)()}`;
+  await import_node_fs14.promises.writeFile(staging, JSON.stringify(journal), {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384,
+    flush: true
+  });
+  await import_node_fs14.promises.rename(staging, target);
+  await syncDirectory(dir);
+}
+async function clearCloudSyncJournal() {
+  const target = getCloudSyncJournalPath();
+  try {
+    await import_node_fs14.promises.unlink(target);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  await syncDirectory(import_node_path19.default.dirname(target));
+}
+
 // ../../packages/runtime-profiles/src/cloud-sync/encryption.ts
-var import_node_child_process10 = require("child_process");
-var import_node_crypto15 = require("crypto");
+var import_node_child_process11 = require("child_process");
+var import_node_crypto17 = require("crypto");
 var KEYCHAIN_SERVICE2 = "CODEXUSE_CLOUD_SYNC_PASSPHRASE";
 var KEYCHAIN_ACCOUNT_PREFIX2 = "license-sha256:";
 var ENCRYPTION_AAD = Buffer.from("codexuse-cloud-sync-v2", "utf8");
@@ -44718,7 +45153,7 @@ function requireCloudSyncPassphrase(value3) {
 }
 async function deriveKey(passphrase, salt, params = SCRYPT_PARAMS) {
   return new Promise((resolve2, reject) => {
-    (0, import_node_crypto15.scrypt)(passphrase, salt, params.keyLength, {
+    (0, import_node_crypto17.scrypt)(passphrase, salt, params.keyLength, {
       N: params.N,
       r: params.r,
       p: params.p,
@@ -44755,10 +45190,10 @@ function normalizeDecryptedSnapshot(value3) {
   };
 }
 async function encryptCloudSyncSnapshot(snapshot2, passphrase) {
-  const salt = (0, import_node_crypto15.randomBytes)(16);
-  const iv = (0, import_node_crypto15.randomBytes)(12);
+  const salt = (0, import_node_crypto17.randomBytes)(16);
+  const iv = (0, import_node_crypto17.randomBytes)(12);
   const key = await deriveKey(requireCloudSyncPassphrase(passphrase), salt);
-  const cipher = (0, import_node_crypto15.createCipheriv)("aes-256-gcm", key, iv);
+  const cipher = (0, import_node_crypto17.createCipheriv)("aes-256-gcm", key, iv);
   cipher.setAAD(ENCRYPTION_AAD);
   const plaintext = Buffer.from(JSON.stringify(snapshot2), "utf8");
   const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
@@ -44785,7 +45220,7 @@ async function decryptCloudSyncSnapshot(snapshot2, passphrase) {
     const tag2 = fromBase64(snapshot2.encryption.tag);
     const ciphertext = fromBase64(snapshot2.encryption.ciphertext);
     const key = await deriveKey(requireCloudSyncPassphrase(passphrase), salt, snapshot2.encryption.kdfParams);
-    const decipher = (0, import_node_crypto15.createDecipheriv)("aes-256-gcm", key, iv);
+    const decipher = (0, import_node_crypto17.createDecipheriv)("aes-256-gcm", key, iv);
     decipher.setAAD(ENCRYPTION_AAD);
     decipher.setAuthTag(tag2);
     const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
@@ -44800,12 +45235,12 @@ async function decryptCloudSyncSnapshot(snapshot2, passphrase) {
   }
 }
 function keychainAccountForLicense(licenseKey) {
-  const digest = (0, import_node_crypto15.createHash)("sha256").update(licenseKey).digest("hex");
+  const digest = (0, import_node_crypto17.createHash)("sha256").update(licenseKey).digest("hex");
   return KEYCHAIN_ACCOUNT_PREFIX2 + digest;
 }
 function runSecurityCommand2(args2) {
   return new Promise((resolve2, reject) => {
-    const child = (0, import_node_child_process10.spawn)("security", args2, { stdio: ["ignore", "pipe", "ignore"] });
+    const child = (0, import_node_child_process11.spawn)("security", args2, { stdio: ["ignore", "pipe", "ignore"] });
     let stdout = "";
     child.stdout?.on("data", (chunk) => {
       stdout += String(chunk);
@@ -45035,8 +45470,7 @@ function formatMegabytes(bytes) {
 }
 async function buildLocalSnapshot(profileManager, options = {}) {
   const enforcePushGuards = options.enforcePushGuards !== false;
-  const profilesFromManager = await profileManager.exportProfilesForCloudSync();
-  const profiles = profilesFromManager;
+  const profiles = await profileManager.exportProfilesForCloudSync();
   const runtimeContext = await resolveCodexRuntimeContext();
   const config = await getCodexConfigSnapshot({
     codexHomePath: runtimeContext.codexHomePath
@@ -45055,25 +45489,183 @@ async function buildLocalSnapshot(profileManager, options = {}) {
     configTomlContent: config.exists ? config.content : null,
     settingsJson
   };
-  if (!enforcePushGuards) {
-    return snapshot2;
-  }
   return snapshot2;
 }
-async function applyRemoteSnapshot(profileManager, snapshot2) {
-  await profileManager.replaceProfilesFromCloudSync(snapshot2.profiles ?? []);
-  if (typeof snapshot2.configTomlContent === "string") {
-    const runtimeContext = await resolveCodexRuntimeContext();
-    await saveCodexConfigContent(snapshot2.configTomlContent, {
-      codexHomePath: runtimeContext.codexHomePath
-    });
+async function applyCloudSyncSnapshot(snapshot2, stores) {
+  const staged = stageCloudSyncSnapshot(snapshot2);
+  const previousSnapshot = await stores.readPrevious();
+  const previous = stageCloudSyncSnapshot(previousSnapshot);
+  const previousHomeIds = await stores.readPreviousHomeIds();
+  await stores.writeJournal({
+    version: 1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    phase: "restore",
+    previous: previousSnapshot,
+    previousHomeIds: { ...previousHomeIds },
+    pendingHomeIds: []
+  });
+  let pendingHomeIds = [];
+  let staleHomes;
+  try {
+    staleHomes = await writeStaged(
+      staged,
+      stores,
+      void 0,
+      async (homeIds) => {
+        pendingHomeIds = [...new Set(homeIds)];
+        await stores.writeJournal({
+          version: 1,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          phase: "restore",
+          previous: previousSnapshot,
+          previousHomeIds: { ...previousHomeIds },
+          pendingHomeIds
+        });
+      }
+    );
+  } catch (error) {
+    await restoreStaged(
+      previousSnapshot,
+      previous,
+      previousHomeIds,
+      pendingHomeIds,
+      stores,
+      error
+    );
+    throw error;
   }
-  if (snapshot2.settingsJson && isRecord7(snapshot2.settingsJson)) {
-    await writeCodexSettingsJsonRaw(snapshot2.settingsJson);
-  } else {
-    await writeCodexSettingsJsonRaw({});
+  await stores.writeJournal({
+    version: 1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    phase: "committed",
+    previous: previousSnapshot,
+    previousHomeIds: { ...previousHomeIds },
+    pendingHomeIds: []
+  });
+  await stores.clearJournal();
+  if (staleHomes.length > 0) {
+    await stores.removeStaleHomes(staleHomes);
+  }
+}
+async function writeStaged(staged, stores, homeIdByProfileName, onPreparedHomeIds) {
+  const staleHomes = await stores.replaceProfiles(
+    staged.profiles,
+    homeIdByProfileName,
+    onPreparedHomeIds
+  );
+  if (staged.configTomlContent !== null || homeIdByProfileName !== void 0) {
+    await stores.writeConfig(staged.configTomlContent);
+  }
+  await stores.writeSettings(staged.settingsJson);
+  return staleHomes;
+}
+async function discardAbandonedHomes(previousSnapshot, previousHomeIds, pendingHomeIds, stores) {
+  if (pendingHomeIds.length === 0) {
+    await stores.clearJournal();
+    return;
+  }
+  await stores.writeJournal({
+    version: 1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    phase: "cleanup",
+    previous: previousSnapshot,
+    previousHomeIds: { ...previousHomeIds },
+    pendingHomeIds
+  });
+  try {
+    const discarded = await stores.discardHomeIds(pendingHomeIds);
+    if (discarded !== pendingHomeIds.length) {
+      throw new Error(
+        `Deleted ${discarded} of ${pendingHomeIds.length} abandoned profile homes.`
+      );
+    }
+  } catch (cleanupError) {
+    logWarn(
+      "[cloud-sync] restored the previous state but could not delete the homes the failed pull created",
+      {
+        error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+      }
+    );
+    return;
+  }
+  await stores.clearJournal();
+}
+async function restoreStaged(previousSnapshot, previous, previousHomeIds, pendingHomeIds, stores, cause) {
+  try {
+    const orphanedByFailedPull = await writeStaged(
+      previous,
+      stores,
+      previousHomeIds
+    );
+    const restoredHomeIds = new Set(Object.values(previousHomeIds));
+    const abandonedHomeIds = [
+      .../* @__PURE__ */ new Set([
+        ...pendingHomeIds,
+        ...stores.homeIdsOf(orphanedByFailedPull)
+      ])
+    ].filter((homeId) => !restoredHomeIds.has(homeId));
+    await discardAbandonedHomes(
+      previousSnapshot,
+      previousHomeIds,
+      abandonedHomeIds,
+      stores
+    );
+    logWarn("[cloud-sync] pull failed and the previous local state was restored", {
+      error: cause instanceof Error ? cause.message : String(cause)
+    });
+  } catch (restoreError) {
+    logWarn(
+      "[cloud-sync] pull failed and the previous local state could not be restored",
+      {
+        error: cause instanceof Error ? cause.message : String(cause),
+        restoreError: restoreError instanceof Error ? restoreError.message : String(restoreError)
+      }
+    );
+    throw new Error(
+      "Cloud pull failed and the previous local state could not be fully restored. Your accounts are still on this Mac; check them before syncing again.",
+      { cause: restoreError }
+    );
   }
 }
+function buildCloudSyncStores(profileManager) {
+  return {
+    readPrevious: () => buildLocalSnapshot(profileManager, { enforcePushGuards: false }),
+    readPreviousHomeIds: () => profileManager.getProfileHomeIdsByName(),
+    replaceProfiles: async (profiles, homeIdByProfileName, onPreparedHomeIds) => (await profileManager.replaceProfilesFromCloudSync(profiles, {
+      deferStaleHomeRemoval: true,
+      homeIdByProfileName,
+      onPreparedHomeIds
+    })).pendingStaleRemovals,
+    writeConfig: async (content) => {
+      const runtimeContext = await resolveCodexRuntimeContext();
+      const options = { codexHomePath: runtimeContext.codexHomePath };
+      if (content === null) {
+        await removeConfigContent(options);
+      } else {
+        await saveCodexConfigContent(content, options);
+      }
+    },
+    writeSettings: (settings) => writeCodexSettingsJsonRaw(settings),
+    removeStaleHomes: (homes) => profileManager.removeStaleProfileHomes(homes),
+    homeIdsOf: (homes) => homes.map((home) => home.homeId),
+    discardHomeIds: (homeIds) => profileManager.deleteAbandonedPullProfileHomes(homeIds),
+    writeJournal: (journal) => writeCloudSyncJournal(journal),
+    clearJournal: () => clearCloudSyncJournal()
+  };
+}
+async function applyRemoteSnapshot(profileManager, snapshot2) {
+  await applyCloudSyncSnapshot(
+    snapshot2,
+    buildCloudSyncStores(profileManager)
+  );
+}
+function stageCloudSyncSnapshot(snapshot2) {
+  return {
+    profiles: snapshot2.profiles ?? [],
+    configTomlContent: typeof snapshot2.configTomlContent === "string" ? assertValidCodexConfigContent(snapshot2.configTomlContent) : null,
+    settingsJson: snapshot2.settingsJson && isRecord7(snapshot2.settingsJson) ? snapshot2.settingsJson : {}
+  };
+}
 function getSnapshotKind(snapshot2) {
   if (!snapshot2) {
     return "none";
@@ -45168,7 +45760,11 @@ async function pushCloudSync(options = {}) {
   const profileManager = new ProfileManager();
   try {
     await profileManager.initialize();
-    const localSnapshot = await buildLocalSnapshot(profileManager, { enforcePushGuards: true });
+    const localSnapshot = await withCloudSyncTransaction(
+      getUserDataDir(),
+      "write",
+      () => buildLocalSnapshot(profileManager, { enforcePushGuards: true })
+    );
     const passphrase = await resolvePassphrase(eligibility.access.syncKey, options);
     const encryptedSnapshot = await encryptCloudSyncSnapshot(localSnapshot, passphrase.value);
     const serializedSnapshot = JSON.stringify(encryptedSnapshot);
@@ -45260,7 +45856,11 @@ async function pullCloudSync(options = {}) {
     } else {
       plainSnapshot = remote;
     }
-    await applyRemoteSnapshot(profileManager, plainSnapshot);
+    await withCloudSyncTransaction(
+      getUserDataDir(),
+      "write",
+      () => applyRemoteSnapshot(profileManager, plainSnapshot)
+    );
     await writeState({
       lastPullAt: (/* @__PURE__ */ new Date()).toISOString(),
       remoteUpdatedAt: remote.updatedAt,
@@ -45366,7 +45966,7 @@ async function handleSync(args2, version) {
 }
 
 // src/commands/workspace.ts
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 function printWorkspaceHelp() {
   console.log(`Usage:
   codexuse workspace bind <path> <profile>
@@ -45396,7 +45996,7 @@ async function handleWorkspaceCommand(args2) {
       return;
     }
     for (const binding of bindings) {
-      const pathState = await import_node_fs14.promises.stat(binding.rootPath).then(() => "").catch(() => " (path missing)");
+      const pathState = await import_node_fs15.promises.stat(binding.rootPath).then(() => "").catch(() => " (path missing)");
       const profileState = profiles.has(binding.profileName) ? "" : " (profile missing)";
       console.log(`${binding.rootPath} -> ${binding.profileName}${pathState}${profileState}`);
     }
@@ -45460,7 +46060,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "6.0.5" : "0.0.0";
+var VERSION = true ? "6.1.0" : "0.0.0";
 async function runCli() {
   const args2 = process.argv.slice(2);
   if (args2.length === 0) {