codexuse-cli 3.9.1 → 3.9.7

package/dist/index.js

@@ -2094,6 +2094,117 @@ function normalizeCommitMessagePrompt(value) {
   return normalized.length > 0 ? normalized : null;
 }
 
+// ../../packages/contracts/src/settings/auto-roll.ts
+var DEFAULT_AUTO_ROLL_ENABLED = false;
+var DEFAULT_AUTO_ROLL_REARM_REMAINING_THRESHOLD = 15;
+var DEFAULT_AUTO_ROLL_SWITCH_REMAINING_THRESHOLD = 5;
+var DEFAULT_RESTART_OFFICIAL_CODEX_ON_AUTO_ROLL = false;
+var DEFAULT_LAUNCH_OFFICIAL_CODEX_WHEN_CLOSED_ON_AUTO_ROLL = false;
+var DEFAULT_AUTO_ROLL_PRIORITY_ORDER = [];
+var DEFAULT_LOW_REMAINING_NOTIFICATION_ENABLED = false;
+var DEFAULT_LOW_REMAINING_NOTIFICATION_THRESHOLD = 1;
+var AUTO_ROLL_SWITCH_REMAINING_MIN = 0;
+var AUTO_ROLL_SWITCH_REMAINING_MAX = 50;
+var AUTO_ROLL_REARM_REMAINING_MAX = 100;
+var LOW_REMAINING_NOTIFICATION_MIN = 1;
+var LOW_REMAINING_NOTIFICATION_MAX = 50;
+function clampNumber(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function resolveFiniteNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function legacyUsedThresholdToRemaining(value, fallbackUsed) {
+  const used = clampNumber(resolveFiniteNumber(value, fallbackUsed), 0, 100);
+  return 100 - used;
+}
+function sanitizeAutoRollSwitchRemainingThreshold(value) {
+  const numeric = resolveFiniteNumber(
+    value,
+    DEFAULT_AUTO_ROLL_SWITCH_REMAINING_THRESHOLD
+  );
+  return clampNumber(
+    numeric,
+    AUTO_ROLL_SWITCH_REMAINING_MIN,
+    AUTO_ROLL_SWITCH_REMAINING_MAX
+  );
+}
+function sanitizeAutoRollRearmRemainingThreshold(value, switchRemainingThreshold) {
+  const sanitizedSwitch = sanitizeAutoRollSwitchRemainingThreshold(
+    switchRemainingThreshold
+  );
+  const numeric = resolveFiniteNumber(
+    value,
+    DEFAULT_AUTO_ROLL_REARM_REMAINING_THRESHOLD
+  );
+  return clampNumber(
+    numeric,
+    sanitizedSwitch + 1,
+    AUTO_ROLL_REARM_REMAINING_MAX
+  );
+}
+function sanitizeAutoRollThresholds(rearmRemainingThreshold, switchRemainingThreshold) {
+  const sanitizedSwitch = sanitizeAutoRollSwitchRemainingThreshold(
+    switchRemainingThreshold
+  );
+  const sanitizedRearm = sanitizeAutoRollRearmRemainingThreshold(
+    rearmRemainingThreshold,
+    sanitizedSwitch
+  );
+  return {
+    rearmRemainingThreshold: sanitizedRearm,
+    switchRemainingThreshold: sanitizedSwitch
+  };
+}
+function sanitizeAutoRollPriorityOrder(value) {
+  if (!Array.isArray(value)) {
+    return [...DEFAULT_AUTO_ROLL_PRIORITY_ORDER];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const item of value) {
+    if (typeof item !== "string") {
+      continue;
+    }
+    const trimmed = item.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    normalized.push(trimmed);
+  }
+  return normalized;
+}
+function sanitizeLowRemainingNotificationThreshold(value) {
+  const numeric = resolveFiniteNumber(value, DEFAULT_LOW_REMAINING_NOTIFICATION_THRESHOLD);
+  return clampNumber(
+    numeric,
+    LOW_REMAINING_NOTIFICATION_MIN,
+    LOW_REMAINING_NOTIFICATION_MAX
+  );
+}
+function normalizeAutoRollSettings(raw) {
+  const enabled = typeof raw?.enabled === "boolean" ? raw.enabled : DEFAULT_AUTO_ROLL_ENABLED;
+  const rawSwitchRemaining = typeof raw?.switchRemainingThreshold === "number" ? raw.switchRemainingThreshold : legacyUsedThresholdToRemaining(raw?.switchThreshold, 95);
+  const rawRearmRemaining = typeof raw?.rearmRemainingThreshold === "number" ? raw.rearmRemainingThreshold : legacyUsedThresholdToRemaining(raw?.warningThreshold, 85);
+  const {
+    rearmRemainingThreshold: normalizedRearm,
+    switchRemainingThreshold: normalizedSwitch
+  } = sanitizeAutoRollThresholds(rawRearmRemaining, rawSwitchRemaining);
+  return {
+    enabled,
+    rearmRemainingThreshold: normalizedRearm,
+    switchRemainingThreshold: normalizedSwitch,
+    restartOfficialCodexOnAutoRoll: raw?.restartOfficialCodexOnAutoRoll === true ? true : DEFAULT_RESTART_OFFICIAL_CODEX_ON_AUTO_ROLL,
+    launchOfficialCodexWhenClosedOnAutoRoll: raw?.launchOfficialCodexWhenClosedOnAutoRoll === true ? true : DEFAULT_LAUNCH_OFFICIAL_CODEX_WHEN_CLOSED_ON_AUTO_ROLL,
+    priorityOrder: sanitizeAutoRollPriorityOrder(raw?.priorityOrder),
+    lowRemainingNotificationEnabled: raw?.lowRemainingNotificationEnabled === true ? true : DEFAULT_LOW_REMAINING_NOTIFICATION_ENABLED,
+    lowRemainingNotificationThreshold: sanitizeLowRemainingNotificationThreshold(
+      typeof raw?.lowRemainingNotificationThreshold === "number" ? raw.lowRemainingNotificationThreshold : Number.NaN
+    )
+  };
+}
+
 // ../../packages/runtime-app-state/src/storage/documents.ts
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
@@ -2351,9 +2462,23 @@ function createDefaultAppState() {
     schemaVersion: 1,
     autoRoll: {
       enabled: false,
-      warningThreshold: 85,
-      switchThreshold: 95,
-      restartOfficialCodexOnAutoRoll: false
+      rearmRemainingThreshold: 15,
+      switchRemainingThreshold: 5,
+      restartOfficialCodexOnAutoRoll: false,
+      launchOfficialCodexWhenClosedOnAutoRoll: false,
+      priorityOrder: [],
+      lowRemainingNotificationEnabled: false,
+      lowRemainingNotificationThreshold: 1
+    },
+    officialCodex: {
+      lastProfileSwitchAt: null,
+      lastProfileSwitchProfileKey: null,
+      lastVerifiedLaunchAt: null,
+      lastVerifiedLaunchProfileKey: null,
+      lastObservedPid: null,
+      lastRestartStatus: null,
+      lastRestartReason: null,
+      instancesByProfileName: {}
     },
     app: {
       lastAppVersion: null,
@@ -2454,34 +2579,72 @@ function asString(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
+function asNumberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function normalizeAppState(raw) {
   const defaults = createDefaultAppState();
   if (!isRecord2(raw)) {
     return defaults;
   }
+  const rawAutoRoll = isRecord2(raw.autoRoll) ? raw.autoRoll : void 0;
   const next = deepMerge(defaults, raw);
   const merged = clone2(next);
   merged.schemaVersion = 1;
-  if (typeof merged.autoRoll.enabled !== "boolean") {
-    merged.autoRoll.enabled = false;
+  merged.autoRoll = normalizeAutoRollSettings(rawAutoRoll);
+  if (!isRecord2(merged.officialCodex)) {
+    merged.officialCodex = clone2(defaults.officialCodex);
   }
-  if (!Number.isFinite(merged.autoRoll.warningThreshold)) {
-    merged.autoRoll.warningThreshold = 85;
-  }
-  if (!Number.isFinite(merged.autoRoll.switchThreshold)) {
-    merged.autoRoll.switchThreshold = 95;
-  }
-  if (merged.autoRoll.warningThreshold < 50 || merged.autoRoll.warningThreshold > 99) {
-    merged.autoRoll.warningThreshold = 85;
-  }
-  if (merged.autoRoll.switchThreshold <= merged.autoRoll.warningThreshold || merged.autoRoll.switchThreshold > 100) {
-    merged.autoRoll.switchThreshold = Math.min(
-      100,
-      Math.max(merged.autoRoll.warningThreshold + 1, 95)
-    );
-  }
-  if (typeof merged.autoRoll.restartOfficialCodexOnAutoRoll !== "boolean") {
-    merged.autoRoll.restartOfficialCodexOnAutoRoll = false;
+  merged.officialCodex.lastProfileSwitchAt = asNumberOrNull(
+    merged.officialCodex.lastProfileSwitchAt
+  );
+  merged.officialCodex.lastProfileSwitchProfileKey = asString(
+    merged.officialCodex.lastProfileSwitchProfileKey
+  );
+  merged.officialCodex.lastVerifiedLaunchAt = asNumberOrNull(
+    merged.officialCodex.lastVerifiedLaunchAt
+  );
+  merged.officialCodex.lastVerifiedLaunchProfileKey = asString(
+    merged.officialCodex.lastVerifiedLaunchProfileKey
+  );
+  merged.officialCodex.lastObservedPid = asNumberOrNull(
+    merged.officialCodex.lastObservedPid
+  );
+  merged.officialCodex.lastRestartStatus = asString(
+    merged.officialCodex.lastRestartStatus
+  );
+  merged.officialCodex.lastRestartReason = asString(
+    merged.officialCodex.lastRestartReason
+  );
+  if (!isRecord2(merged.officialCodex.instancesByProfileName)) {
+    merged.officialCodex.instancesByProfileName = {};
+  } else {
+    const nextInstances = {};
+    for (const [key, value] of Object.entries(
+      merged.officialCodex.instancesByProfileName
+    )) {
+      if (!isRecord2(value)) {
+        continue;
+      }
+      const profileName = asString(value.profileName) ?? asString(key);
+      if (!profileName) {
+        continue;
+      }
+      nextInstances[profileName] = {
+        profileName,
+        profileKey: asString(value.profileKey),
+        profileHome: asString(value.profileHome),
+        appPath: asString(value.appPath),
+        bundleId: asString(value.bundleId),
+        pid: asNumberOrNull(value.pid),
+        appServerPid: asNumberOrNull(value.appServerPid),
+        launchedAt: asNumberOrNull(value.launchedAt),
+        lastVerifiedAt: asNumberOrNull(value.lastVerifiedAt),
+        lastStatus: asString(value.lastStatus),
+        lastError: asString(value.lastError)
+      };
+    }
+    merged.officialCodex.instancesByProfileName = nextInstances;
   }
   merged.app.lastAppVersion = asString(merged.app.lastAppVersion);
   merged.app.pendingUpdateVersion = asString(merged.app.pendingUpdateVersion);
@@ -2977,59 +3140,6 @@ async function writeAppSettings(settings, onUpdated) {
 // ../../packages/runtime-profiles/src/license/service.ts
 var import_node_crypto2 = __toESM(require("crypto"), 1);
 
-// ../../packages/contracts/src/settings/auto-roll.ts
-var DEFAULT_AUTO_ROLL_ENABLED = false;
-var DEFAULT_AUTO_ROLL_WARNING_THRESHOLD = 85;
-var DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD = 95;
-var DEFAULT_RESTART_OFFICIAL_CODEX_ON_AUTO_ROLL = false;
-var AUTO_ROLL_WARNING_MIN = 50;
-var AUTO_ROLL_WARNING_MAX = 99;
-var AUTO_ROLL_SWITCH_MAX = 100;
-function clampNumber(value, min, max) {
-  return Math.min(max, Math.max(min, value));
-}
-function resolveFiniteNumber(value, fallback) {
-  return Number.isFinite(value) ? value : fallback;
-}
-function sanitizeAutoRollWarningThreshold(value) {
-  const numeric = resolveFiniteNumber(value, DEFAULT_AUTO_ROLL_WARNING_THRESHOLD);
-  return clampNumber(numeric, AUTO_ROLL_WARNING_MIN, AUTO_ROLL_WARNING_MAX);
-}
-function sanitizeAutoRollSwitchThreshold(value, warningThreshold) {
-  const sanitizedWarning = sanitizeAutoRollWarningThreshold(warningThreshold);
-  const numeric = resolveFiniteNumber(value, DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD);
-  return clampNumber(numeric, sanitizedWarning + 1, AUTO_ROLL_SWITCH_MAX);
-}
-function sanitizeAutoRollThresholds(warningThreshold, switchThreshold) {
-  const sanitizedWarning = sanitizeAutoRollWarningThreshold(warningThreshold);
-  const sanitizedSwitch = sanitizeAutoRollSwitchThreshold(switchThreshold, sanitizedWarning);
-  return {
-    warningThreshold: sanitizedWarning,
-    switchThreshold: sanitizedSwitch
-  };
-}
-function normalizeAutoRollSettings(raw) {
-  const enabled = typeof raw?.enabled === "boolean" ? raw.enabled : DEFAULT_AUTO_ROLL_ENABLED;
-  const rawWarning = resolveFiniteNumber(
-    typeof raw?.warningThreshold === "number" ? raw.warningThreshold : Number.NaN,
-    DEFAULT_AUTO_ROLL_WARNING_THRESHOLD
-  );
-  const rawSwitch = resolveFiniteNumber(
-    typeof raw?.switchThreshold === "number" ? raw.switchThreshold : Number.NaN,
-    DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD
-  );
-  const {
-    warningThreshold: normalizedWarning,
-    switchThreshold: normalizedSwitch
-  } = sanitizeAutoRollThresholds(rawWarning, rawSwitch);
-  return {
-    enabled,
-    warningThreshold: normalizedWarning,
-    switchThreshold: normalizedSwitch,
-    restartOfficialCodexOnAutoRoll: raw?.restartOfficialCodexOnAutoRoll === true ? true : DEFAULT_RESTART_OFFICIAL_CODEX_ON_AUTO_ROLL
-  };
-}
-
 // ../../packages/runtime-codex/src/codex/settings.ts
 function asString2(value) {
   if (typeof value !== "string") {
@@ -3071,17 +3181,6 @@ function parseStoredLicense(raw) {
   );
   return hasValue ? license : null;
 }
-async function getLastProfileName() {
-  const state = await getAppState();
-  return asString2(state.app.lastProfileName);
-}
-async function persistLastProfileName(profileName) {
-  await patchAppState({
-    app: {
-      lastProfileName: asString2(profileName)
-    }
-  });
-}
 async function getStoredLicense() {
   const state = await getAppState();
   return parseStoredLicense(state.license);
@@ -3150,9 +3249,13 @@ async function writeCodexSettingsJsonRaw(payload) {
     },
     autoRoll: autoRoll ? {
       enabled: autoRoll.enabled,
-      warningThreshold: autoRoll.warningThreshold,
-      switchThreshold: autoRoll.switchThreshold,
-      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll
+      rearmRemainingThreshold: autoRoll.rearmRemainingThreshold,
+      switchRemainingThreshold: autoRoll.switchRemainingThreshold,
+      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll,
+      launchOfficialCodexWhenClosedOnAutoRoll: autoRoll.launchOfficialCodexWhenClosedOnAutoRoll,
+      priorityOrder: autoRoll.priorityOrder,
+      lowRemainingNotificationEnabled: autoRoll.lowRemainingNotificationEnabled,
+      lowRemainingNotificationThreshold: autoRoll.lowRemainingNotificationThreshold
     } : void 0,
     license: license ? {
       licenseKey: license.licenseKey ?? null,
@@ -4245,21 +4348,6 @@ var ProfileManager = class {
       error && typeof error === "object" && "code" in error && error.code === "ENOENT"
     );
   }
-  async readPreferredProfileName() {
-    try {
-      return await getLastProfileName();
-    } catch (error) {
-      logWarn("Failed to read preferred profile name:", error);
-      return null;
-    }
-  }
-  async persistPreferredProfileName(name) {
-    try {
-      await persistLastProfileName(name);
-    } catch (error) {
-      logWarn("Failed to persist preferred profile name:", error);
-    }
-  }
   toStateRecord(record) {
     return {
       name: record.name,
@@ -4379,47 +4467,36 @@ var ProfileManager = class {
       return null;
     }
   }
-  async captureActiveAuthSnapshot() {
-    await this.initialize();
+  emptyAuthSnapshot(fingerprint = null) {
+    return {
+      fingerprint,
+      email: null,
+      accountId: null,
+      userId: null,
+      chatgptUserId: null,
+      chatgptAccountUserId: null,
+      workspaceId: null
+    };
+  }
+  async captureAuthSnapshotAtPath(authPath) {
     let raw;
     try {
-      raw = await import_fs.promises.readFile(this.activeAuth, "utf8");
+      raw = await import_fs.promises.readFile(authPath, "utf8");
     } catch (error) {
       if (this.isNotFoundError(error)) {
-        return {
-          fingerprint: null,
-          email: null,
-          accountId: null,
-          userId: null,
-          chatgptUserId: null,
-          workspaceId: null
-        };
+        return this.emptyAuthSnapshot();
       }
       const message = error instanceof Error ? error.message : "unknown error";
-      const signature = typeof message === "string" ? `${message}:${this.activeAuth}` : this.activeAuth;
+      const signature = typeof message === "string" ? `${message}:${authPath}` : authPath;
       if (this.lastActiveAuthErrorSignature !== signature) {
-        logWarn("Failed to snapshot active auth file:", error);
+        logWarn("Failed to snapshot auth file:", error);
         this.lastActiveAuthErrorSignature = signature;
       }
-      return {
-        fingerprint: null,
-        email: null,
-        accountId: null,
-        userId: null,
-        chatgptUserId: null,
-        workspaceId: null
-      };
+      return this.emptyAuthSnapshot();
     }
     const trimmed = raw.trim();
     if (!trimmed) {
-      return {
-        fingerprint: null,
-        email: null,
-        accountId: null,
-        userId: null,
-        chatgptUserId: null,
-        workspaceId: null
-      };
+      return this.emptyAuthSnapshot();
     }
     const fingerprint = (0, import_node_crypto3.createHash)("sha256").update(trimmed).digest("hex");
     try {
@@ -4433,19 +4510,27 @@ var ProfileManager = class {
         accountId: this.getAccountIdFromData(normalized) ?? null,
         userId: metadata?.userId ?? null,
         chatgptUserId: metadata?.chatgptUserId ?? null,
+        chatgptAccountUserId: metadata?.chatgptAccountUserId ?? null,
         workspaceId: workspace.id ?? null
       };
     } catch {
-      return {
-        fingerprint,
-        email: null,
-        accountId: null,
-        userId: null,
-        chatgptUserId: null,
-        workspaceId: null
-      };
+      return this.emptyAuthSnapshot(fingerprint);
     }
   }
+  async captureAuthSnapshot(authPath) {
+    const targetPath = authPath ?? this.activeAuth;
+    if (targetPath === this.activeAuth) {
+      return this.enqueueAuthSwap(async () => {
+        await this.initialize();
+        return this.captureAuthSnapshotAtPath(targetPath);
+      });
+    }
+    await this.initialize();
+    return this.captureAuthSnapshotAtPath(targetPath);
+  }
+  async captureActiveAuthSnapshot() {
+    return this.captureAuthSnapshot(this.activeAuth);
+  }
   /**
    * Decode a JWT payload into an object without validating the signature.
    */
@@ -4842,6 +4927,130 @@ var ProfileManager = class {
       metadata: record.metadata
     }) ?? resolveFallbackAccountKey(record.name);
   }
+  describeActiveAuth(auth) {
+    const normalized = this.normalizeProfileData(auth);
+    if (typeof normalized.auth_method === "string") {
+      normalized.auth_method = normalized.auth_method.trim().toLowerCase();
+    }
+    normalized.auth_method = normalized.auth_method ?? "codex-cli";
+    const metadata = this.extractProfileMetadata(normalized);
+    const workspace = this.resolveWorkspaceIdentity(normalized, metadata);
+    const workspaceId = workspace.id || DEFAULT_WORKSPACE_ID;
+    const workspaceName = workspace.name ?? null;
+    normalized.workspace_id = normalized.workspace_id ?? workspaceId;
+    if (workspaceName) {
+      normalized.workspace_name = normalized.workspace_name ?? workspaceName;
+    }
+    const email = this.resolveProfileEmail(normalized, metadata) ?? null;
+    if (email) {
+      normalized.email = email;
+    }
+    const accountId = this.getAccountIdFromData(normalized) ?? null;
+    const identityKey = this.resolveProfileIdentityFromData(null, normalized, metadata);
+    const hasTokenPayload = Boolean(
+      normalized.id_token || normalized.access_token || normalized.refresh_token || accountId || email
+    );
+    return {
+      normalized,
+      metadata,
+      workspaceId,
+      workspaceName,
+      email,
+      accountId,
+      identityKey,
+      hasTokenPayload
+    };
+  }
+  async findProfileForActiveAuth(identityKey, workspaceId) {
+    return this.getProfileRowByIdentityAndWorkspace(identityKey, workspaceId, {
+      preferAuthMethod: "codex-cli"
+    });
+  }
+  async syncMatchedProfileFromActiveAuth(record, description) {
+    if (!this.hasTokenChanges(record.data, description.normalized)) {
+      return;
+    }
+    const { profile: merged, metadata } = this.mergeProfileRecords(record.data, description.normalized);
+    delete merged.tokenAlert;
+    await this.persistProfileRecord(record.name, merged, metadata);
+  }
+  async assertActiveAuthMatchesRecord(record, message) {
+    const activeAuth = await this.readActiveAuthFile();
+    if (!activeAuth) {
+      throw new Error("Active Codex auth is missing. Refresh profiles and try again.");
+    }
+    const activeDescription = this.describeActiveAuth(activeAuth);
+    const targetIdentity = this.resolveProfileIdentityFromRecord(record);
+    const targetWorkspaceId = this.normalizeWorkspaceId(record.workspaceId ?? record.data.workspace_id);
+    if (activeDescription.identityKey !== targetIdentity || this.normalizeWorkspaceId(activeDescription.workspaceId) !== targetWorkspaceId) {
+      throw new Error(message);
+    }
+  }
+  async writeActiveAuthForRecord(record) {
+    const profileData = record.data;
+    const targetIdentity = this.resolveProfileIdentityFromRecord(record);
+    const targetWorkspaceId = this.normalizeWorkspaceId(record.workspaceId ?? profileData.workspace_id);
+    const codexFormat = this.convertToCodexFormat(profileData);
+    await this.writeAtomic(this.activeAuth, JSON.stringify(codexFormat, null, 2));
+    const written = await this.readActiveAuthFile();
+    if (!written) {
+      throw new Error("Codex auth file was not written.");
+    }
+    const writtenDescription = this.describeActiveAuth(written);
+    if (writtenDescription.identityKey !== targetIdentity) {
+      throw new Error("Codex auth verification failed after profile switch.");
+    }
+    if (this.normalizeWorkspaceId(writtenDescription.workspaceId) !== targetWorkspaceId) {
+      throw new Error("Codex auth workspace verification failed after profile switch.");
+    }
+  }
+  async syncActiveAuthFromProfileIfCurrent(name) {
+    const profileName = this.normalizeProfileName(name);
+    const record = await this.getProfileRowByName(profileName);
+    if (!record) {
+      return;
+    }
+    const activeAuth = await this.readActiveAuthFile();
+    if (!activeAuth) {
+      return;
+    }
+    const activeDescription = this.describeActiveAuth(activeAuth);
+    const targetIdentity = this.resolveProfileIdentityFromRecord(record);
+    const targetWorkspaceId = this.normalizeWorkspaceId(record.workspaceId ?? record.data.workspace_id);
+    if (activeDescription.identityKey !== targetIdentity || this.normalizeWorkspaceId(activeDescription.workspaceId) !== targetWorkspaceId) {
+      return;
+    }
+    await this.writeActiveAuthForRecord(record);
+  }
+  async removeActiveAuthFiles() {
+    await import_fs.promises.rm(this.activeAuth, { force: true });
+    await import_fs.promises.rm(this.activeAuthBackup, { force: true });
+    await import_fs.promises.rm(`${this.activeAuth}.tmp`, { force: true });
+  }
+  resolveAutoImportedProfileName(email, existingRecords) {
+    const source = email ? email.split("@")[0] : "codex-account";
+    const base = source.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "codex-account";
+    const used = new Set(existingRecords.map((record) => record.name));
+    let candidate = this.normalizeProfileName(base);
+    let suffix = 2;
+    while (used.has(candidate)) {
+      candidate = this.normalizeProfileName(`${base}-${suffix}`);
+      suffix += 1;
+    }
+    return candidate;
+  }
+  buildActiveCodexAuthStatus(state, description, options) {
+    return {
+      state,
+      profileName: options?.profileName ?? null,
+      email: description?.email ?? null,
+      accountId: description?.accountId ?? null,
+      workspaceId: description?.workspaceId ?? null,
+      workspaceName: description?.workspaceName ?? null,
+      importedProfileName: options?.importedProfileName ?? null,
+      importBlockedReason: options?.importBlockedReason ?? null
+    };
+  }
   resolveWorkspaceIdentity(data, metadata) {
     const directId = "workspace_id" in data && typeof data.workspace_id === "string" ? data.workspace_id.trim() : void 0;
     const directName = "workspace_name" in data && typeof data.workspace_name === "string" ? data.workspace_name.trim() : void 0;
@@ -4862,22 +5071,6 @@ var ProfileManager = class {
     const record = await this.readProfileRecord(normalized);
     return record ?? void 0;
   }
-  async getProfileRowByIdentityKey(identityKey, options) {
-    const records = await this.listProfileRecords();
-    const matches = records.filter((record) => this.resolveProfileIdentityFromRecord(record) === identityKey);
-    if (matches.length === 0) {
-      return void 0;
-    }
-    const mustMatch = typeof options?.authMethod === "string" ? options.authMethod.trim().toLowerCase() : null;
-    if (mustMatch) {
-      return matches.find((record) => this.resolveAuthMethod(record.data) === mustMatch);
-    }
-    const prefer = typeof options?.preferAuthMethod === "string" ? options.preferAuthMethod.trim().toLowerCase() : null;
-    if (prefer) {
-      return matches.find((record) => this.resolveAuthMethod(record.data) === prefer) ?? matches[0];
-    }
-    return matches[0];
-  }
   async getProfileRowByIdentityAndWorkspace(identityKey, workspaceId, options) {
     const workspaceKey = workspaceId && workspaceId.trim().length > 0 ? workspaceId.trim() : DEFAULT_WORKSPACE_ID;
     const records = await this.listProfileRecords();
@@ -4901,6 +5094,9 @@ var ProfileManager = class {
     }
     return matches[0];
   }
+  normalizeWorkspaceId(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : DEFAULT_WORKSPACE_ID;
+  }
   async persistProfileRecord(name, data, metadata, options) {
     const resolvedName = this.normalizeProfileName(name);
     const existingRecord = await this.readProfileRecord(resolvedName);
@@ -4960,6 +5156,22 @@ var ProfileManager = class {
     });
     return profile;
   }
+  async deleteProfileRecordAndHome(record) {
+    const profileName = this.normalizeProfileName(record.name);
+    if (!record.accountId) {
+      const dashboardState = await this.readProfileDashboardState();
+      delete dashboardState.customGroupsByAccountKey[resolveFallbackAccountKey(profileName)];
+      await this.writeProfileDashboardState(dashboardState);
+    }
+    try {
+      await import_fs.promises.rm(this.getProfileHomePath(profileName), { recursive: true, force: true });
+    } catch (error) {
+      if (!this.isNotFoundError(error)) {
+        logWarn(`Failed to remove profile home for '${profileName}':`, error);
+      }
+    }
+    await this.deleteProfileRecord(profileName);
+  }
   buildProfileFromData(name, data, fallback) {
     const metadata = fallback?.metadata ?? this.extractProfileMetadata(data);
     const workspace = this.resolveWorkspaceIdentity(data, metadata);
@@ -5019,6 +5231,18 @@ var ProfileManager = class {
     if (normalizedLastRefresh) {
       codexAuth.last_refresh = normalizedLastRefresh;
     }
+    const email = typeof data.email === "string" ? data.email.trim() : "";
+    if (email) {
+      codexAuth.email = email;
+    }
+    const workspaceId = typeof data.workspace_id === "string" ? data.workspace_id.trim() : "";
+    if (workspaceId) {
+      codexAuth.workspace_id = workspaceId;
+    }
+    const workspaceName = typeof data.workspace_name === "string" ? data.workspace_name.trim() : "";
+    if (workspaceName) {
+      codexAuth.workspace_name = workspaceName;
+    }
     return codexAuth;
   }
   /**
@@ -5041,8 +5265,17 @@ var ProfileManager = class {
     if (normalizedLastRefresh) {
       profile.last_refresh = normalizedLastRefresh;
     }
-    if (data.email) {
-      profile.email = data.email;
+    const email = typeof data.email === "string" ? data.email.trim() : "";
+    if (email) {
+      profile.email = email;
+    }
+    const workspaceId = typeof data.workspace_id === "string" ? data.workspace_id.trim() : "";
+    if (workspaceId) {
+      profile.workspace_id = workspaceId;
+    }
+    const workspaceName = typeof data.workspace_name === "string" ? data.workspace_name.trim() : "";
+    if (workspaceName) {
+      profile.workspace_name = workspaceName;
     }
     return profile;
   }
@@ -5174,6 +5407,12 @@ var ProfileManager = class {
       );
       return;
     }
+    if (this.normalizeWorkspaceId(existing.workspace_id) !== this.normalizeWorkspaceId(normalized.workspace_id)) {
+      logWarn(
+        `Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different workspace.`
+      );
+      return;
+    }
     if (!this.hasTokenChanges(existing, normalized)) {
       return;
     }
@@ -5371,94 +5610,80 @@ var ProfileManager = class {
         }
         if (finalAuthContent) {
           await this.syncProfileTokensFromAuthContent(profileName, record.data, finalAuthContent);
+          await this.syncActiveAuthFromProfileIfCurrent(profileName);
           return;
         }
         await this.syncProfileTokensFromActiveAuth(profileName, record.data, authPath);
+        await this.syncActiveAuthFromProfileIfCurrent(profileName);
       })
     );
   }
   /**
    * Create a new profile by running codex login
    */
-  async createProfile(name) {
-    await this.initialize();
-    const profileName = this.normalizeProfileName(name);
-    if (await this.getProfileRowByName(profileName)) {
-      throw new Error(`Profile '${profileName}' already exists!`);
-    }
-    let authData;
+  async readAuthFileForImport(authPath, actionLabel) {
+    let authRaw;
     try {
-      const authRaw = await import_fs.promises.readFile(this.activeAuth, "utf8");
-      authData = JSON.parse(authRaw);
+      authRaw = await import_fs.promises.readFile(authPath, "utf8");
     } catch (error) {
-      logError("Error creating profile:", error);
-      throw new Error("Failed to create profile. Make sure Codex CLI is installed and you are logged in.");
-    }
-    const normalizedProfile = this.normalizeProfileData(authData);
-    normalizedProfile.created_at = normalizedProfile.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
-    if (typeof normalizedProfile.auth_method === "string") {
-      normalizedProfile.auth_method = normalizedProfile.auth_method.trim().toLowerCase();
-    }
-    normalizedProfile.auth_method = normalizedProfile.auth_method ?? "codex-cli";
-    const metadata = this.extractProfileMetadata(normalizedProfile);
-    const workspace = this.resolveWorkspaceIdentity(normalizedProfile, metadata);
-    normalizedProfile.workspace_id = normalizedProfile.workspace_id ?? workspace.id ?? DEFAULT_WORKSPACE_ID;
-    if (workspace.name) {
-      normalizedProfile.workspace_name = normalizedProfile.workspace_name ?? workspace.name;
-    }
-    const resolvedEmail = this.resolveProfileEmail(normalizedProfile, metadata);
-    if (resolvedEmail) {
-      normalizedProfile.email = resolvedEmail;
+      if (this.isNotFoundError(error)) {
+        throw new Error(`Codex CLI did not produce an auth file. Complete the login before ${actionLabel}.`);
+      }
+      logError(`Failed to read Codex auth file during ${actionLabel}:`, error);
+      throw new Error("Failed to read Codex auth file. Complete the login and try again.");
     }
     try {
-      await this.persistProfileRecord(profileName, normalizedProfile, metadata);
-      const stored = await this.getProfileRowByName(profileName);
-      return stored ? this.buildProfileFromRow(stored) : null;
+      return JSON.parse(authRaw);
     } catch (error) {
-      logError("Error creating profile:", error);
-      throw new Error("Failed to create profile. Make sure Codex CLI is installed and you are logged in.");
+      logError(`Failed to parse Codex auth file during ${actionLabel}:`, error);
+      throw new Error("Failed to parse Codex auth file. Complete the login and try again.");
     }
   }
-  /**
-   * Switch to a different profile
-   */
-  async switchToProfile(name) {
-    await this.initialize();
+  async persistNewProfileFromAuth(profileName, authData) {
+    const description = this.describeActiveAuth(authData);
+    const normalizedProfile = description.normalized;
+    normalizedProfile.created_at = normalizedProfile.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
+    await this.persistProfileRecord(profileName, normalizedProfile, description.metadata);
+    const stored = await this.getProfileRowByName(profileName);
+    return stored ? this.buildProfileFromRow(stored) : null;
+  }
+  async createProfile(name) {
     const profileName = this.normalizeProfileName(name);
-    const record = await this.getProfileRowByName(profileName);
-    if (!record) {
-      throw new Error(`Profile '${profileName}' not found!`);
-    }
-    try {
-      const profileData = record.data;
-      const codexFormat = this.convertToCodexFormat(profileData);
-      await this.writeAtomic(this.activeAuth, JSON.stringify(codexFormat, null, 2));
-      await this.persistPreferredProfileName(profileName);
-      return true;
-    } catch (error) {
-      logError("Error switching profile:", error);
-      throw new Error("Failed to switch profile");
-    }
+    return this.enqueueProfileOperation(
+      profileName,
+      () => this.enqueueAuthSwap(async () => {
+        await this.initialize();
+        if (await this.getProfileRowByName(profileName)) {
+          throw new Error(`Profile '${profileName}' already exists!`);
+        }
+        try {
+          const authData = await this.readAuthFileForImport(this.activeAuth, "profile creation");
+          return await this.persistNewProfileFromAuth(profileName, authData);
+        } catch (error) {
+          logError("Error creating profile:", error);
+          throw new Error("Failed to create profile. Make sure Codex CLI is installed and you are logged in.");
+        }
+      })
+    );
   }
-  async refreshProfileAuth(name) {
-    await this.initialize();
+  async createProfileFromAuthFile(name, authPath) {
     const profileName = this.normalizeProfileName(name);
-    const record = await this.getProfileRowByName(profileName);
-    if (!record) {
-      throw new Error(`Profile '${profileName}' not found!`);
-    }
-    const existing = record.data;
-    let activeAuth;
-    try {
-      const authContent = await import_fs.promises.readFile(this.activeAuth, "utf8");
-      activeAuth = JSON.parse(authContent);
-    } catch (error) {
-      if (this.isNotFoundError(error)) {
-        throw new Error("Codex CLI did not produce an auth file. Complete the login before refreshing this profile.");
+    return this.enqueueProfileOperation(profileName, async () => {
+      await this.initialize();
+      if (await this.getProfileRowByName(profileName)) {
+        throw new Error(`Profile '${profileName}' already exists!`);
       }
-      logError("Failed to read Codex auth file during refresh:", error);
-      throw new Error("Failed to read Codex auth file. Complete the login and try again.");
-    }
+      try {
+        const authData = await this.readAuthFileForImport(authPath, "profile creation");
+        return await this.persistNewProfileFromAuth(profileName, authData);
+      } catch (error) {
+        logError("Error creating profile:", error);
+        throw new Error("Failed to create profile. Make sure Codex CLI is installed and you are logged in.");
+      }
+    });
+  }
+  async refreshProfileAuthWithData(profileName, record, activeAuth) {
+    const existing = record.data;
     const normalized = this.normalizeProfileData(activeAuth);
     const existingMetadata = record.metadata ?? this.extractProfileMetadata(existing);
     const currentWorkspace = this.resolveWorkspaceIdentity(existing, existingMetadata);
@@ -5507,6 +5732,60 @@ var ProfileManager = class {
     }
     return profile;
   }
+  /**
+   * Switch to a different profile
+   */
+  async switchToProfile(name) {
+    const profileName = this.normalizeProfileName(name);
+    return this.enqueueProfileOperation(
+      profileName,
+      () => this.enqueueAuthSwap(async () => {
+        await this.initialize();
+        const record = await this.getProfileRowByName(profileName);
+        if (!record) {
+          throw new Error(`Profile '${profileName}' not found!`);
+        }
+        try {
+          await this.writeActiveAuthForRecord(record);
+          return true;
+        } catch (error) {
+          logError("Error switching profile:", error);
+          throw new Error("Failed to switch profile");
+        }
+      })
+    );
+  }
+  async refreshProfileAuth(name) {
+    const profileName = this.normalizeProfileName(name);
+    return this.enqueueProfileOperation(
+      profileName,
+      () => this.enqueueAuthSwap(async () => {
+        await this.initialize();
+        const record = await this.getProfileRowByName(profileName);
+        if (!record) {
+          throw new Error(`Profile '${profileName}' not found!`);
+        }
+        const activeAuth = await this.readAuthFileForImport(this.activeAuth, "profile refresh");
+        return this.refreshProfileAuthWithData(profileName, record, activeAuth);
+      })
+    );
+  }
+  async refreshProfileAuthFromFile(name, authPath) {
+    const profileName = this.normalizeProfileName(name);
+    return this.enqueueProfileOperation(profileName, async () => {
+      await this.initialize();
+      const record = await this.getProfileRowByName(profileName);
+      if (!record) {
+        throw new Error(`Profile '${profileName}' not found!`);
+      }
+      const activeAuth = await this.readAuthFileForImport(authPath, "profile refresh");
+      const profile = await this.refreshProfileAuthWithData(profileName, record, activeAuth);
+      await this.enqueueAuthSwap(async () => {
+        await this.syncActiveAuthFromProfileIfCurrent(profileName);
+      });
+      return profile;
+    });
+  }
   /**
    * Execute an action with a profile's auth injected.
    * Creates an isolated CODEX_HOME with the profile's auth/config, invokes the action
@@ -5515,22 +5794,35 @@ var ProfileManager = class {
   async runWithProfileAuth(name, action) {
     return this.enqueueProfileOperation(
       name,
-      () => this.enqueueAuthSwap(
-        () => this.runWithPreparedProfileHome(name, action, {
-          syncFromActiveAuthBeforeAction: true
-        })
-      )
+      () => this.enqueueAuthSwap(async () => {
+        try {
+          return await this.runWithPreparedProfileHome(name, action, {
+            syncFromActiveAuthBeforeAction: true
+          });
+        } finally {
+          await this.syncActiveAuthFromProfileIfCurrent(name);
+        }
+      })
     );
   }
   async readLiveRateLimits(name, options = {}) {
-    return this.enqueueProfileOperation(
-      name,
-      () => this.runWithPreparedProfileHome(
-        name,
-        (env) => fetchRateLimitsViaRpc(env, { codexPath: options.codexPath }),
-        { syncFromActiveAuthBeforeAction: false }
-      )
-    );
+    const profileName = this.normalizeProfileName(name);
+    try {
+      return await this.enqueueProfileOperation(
+        profileName,
+        () => this.runWithPreparedProfileHome(
+          profileName,
+          (env) => fetchRateLimitsViaRpc(env, { codexPath: options.codexPath }),
+          { syncFromActiveAuthBeforeAction: false }
+        )
+      );
+    } finally {
+      await this.enqueueAuthSwap(async () => {
+        await this.syncActiveAuthFromProfileIfCurrent(profileName);
+      }).catch((error) => {
+        logWarn(`Failed to sync active auth after rate-limit probe for '${profileName}':`, error);
+      });
+    }
   }
   /**
    * Rename a profile
@@ -5546,10 +5838,6 @@ var ProfileManager = class {
     if (await this.getProfileRowByName(targetName)) {
       throw new Error(`Profile '${targetName}' already exists!`);
     }
-    const preferred = await this.readPreferredProfileName();
-    if (preferred && preferred === sourceName) {
-      await this.persistPreferredProfileName(targetName);
-    }
     const oldHome = this.getProfileHomePath(sourceName);
     const newHome = this.getProfileHomePath(targetName);
     try {
@@ -5618,25 +5906,51 @@ var ProfileManager = class {
     if (!record) {
       throw new Error(`Profile '${profileName}' not found!`);
     }
-    if (!record.accountId) {
-      const dashboardState = await this.readProfileDashboardState();
-      delete dashboardState.customGroupsByAccountKey[resolveFallbackAccountKey(profileName)];
-      await this.writeProfileDashboardState(dashboardState);
-    }
-    const preferred = await this.readPreferredProfileName();
-    if (preferred && preferred === profileName) {
-      await this.persistPreferredProfileName(null);
-    }
-    try {
-      await import_fs.promises.rm(this.getProfileHomePath(profileName), { recursive: true, force: true });
-    } catch (error) {
-      if (!this.isNotFoundError(error)) {
-        logWarn(`Failed to remove profile home for '${profileName}':`, error);
-      }
-    }
-    await this.deleteProfileRecord(profileName);
+    await this.deleteProfileRecordAndHome(record);
     return true;
   }
+  async deleteActiveProfileAndSwitch(name, replacementName) {
+    const profileName = this.normalizeProfileName(name);
+    const nextProfileName = this.normalizeProfileName(replacementName);
+    if (profileName === nextProfileName) {
+      throw new Error("Replacement profile must be different from the deleted profile.");
+    }
+    return this.enqueueAuthSwap(async () => {
+      await this.initialize();
+      const record = await this.getProfileRowByName(profileName);
+      if (!record) {
+        throw new Error(`Profile '${profileName}' not found!`);
+      }
+      const replacement = await this.getProfileRowByName(nextProfileName);
+      if (!replacement) {
+        throw new Error(`Profile '${nextProfileName}' not found!`);
+      }
+      await this.assertActiveAuthMatchesRecord(
+        record,
+        "Active Codex login changed before deletion. Refresh profiles and try again."
+      );
+      await this.writeActiveAuthForRecord(replacement);
+      await this.deleteProfileRecordAndHome(record);
+      return true;
+    });
+  }
+  async deleteActiveProfileAndAuth(name) {
+    const profileName = this.normalizeProfileName(name);
+    return this.enqueueAuthSwap(async () => {
+      await this.initialize();
+      const record = await this.getProfileRowByName(profileName);
+      if (!record) {
+        throw new Error(`Profile '${profileName}' not found!`);
+      }
+      await this.assertActiveAuthMatchesRecord(
+        record,
+        "Active Codex login changed before deletion. Refresh profiles and try again."
+      );
+      await this.removeActiveAuthFiles();
+      await this.deleteProfileRecordAndHome(record);
+      return true;
+    });
+  }
   /**
    * Delete every profile that does not appear in the allow-list.
    * Used to enforce plan limits when local storage was tampered with.
@@ -5673,64 +5987,61 @@ var ProfileManager = class {
         }
       }
     }
-    const preferred = await this.readPreferredProfileName();
-    if (preferred && removed.includes(preferred)) {
-      await this.persistPreferredProfileName(null);
-    }
     return removed;
   }
-  /**
-   * Check if the current auth matches a profile (for smart detection)
-   */
-  async getCurrentProfile() {
-    await this.initialize();
-    const preferredName = await this.readPreferredProfileName();
-    if (preferredName) {
-      try {
-        const normalizedPreferred = this.normalizeProfileName(preferredName);
-        const preferredRecord = await this.getProfileRowByName(normalizedPreferred);
-        if (preferredRecord) {
-          return { name: normalizedPreferred, trusted: true };
-        }
-      } catch {
+  async getActiveCodexAuthStatus(options = {}) {
+    return this.enqueueAuthSwap(async () => {
+      await this.initialize();
+      const activeAuth = await this.readActiveAuthFile();
+      if (!activeAuth) {
+        return this.buildActiveCodexAuthStatus("missing");
       }
-    }
-    const activeAuth = await this.readActiveAuthFile();
-    if (activeAuth) {
-      const normalizedAuth = this.normalizeProfileData(activeAuth);
-      const authMetadata = this.extractProfileMetadata(normalizedAuth);
-      const workspace = this.resolveWorkspaceIdentity(normalizedAuth, authMetadata);
-      const activeIdentityKey = this.resolveProfileIdentityFromData(null, normalizedAuth, authMetadata);
-      if (activeIdentityKey) {
-        const scoped = await this.getProfileRowByIdentityAndWorkspace(activeIdentityKey, workspace.id ?? DEFAULT_WORKSPACE_ID, {
-          preferAuthMethod: "codex-cli"
+      const description = this.describeActiveAuth(activeAuth);
+      if (!description.hasTokenPayload || !description.identityKey) {
+        return this.buildActiveCodexAuthStatus("unknown", description);
+      }
+      const matching = await this.findProfileForActiveAuth(
+        description.identityKey,
+        description.workspaceId
+      );
+      if (matching) {
+        const normalized = this.normalizeProfileName(matching.name);
+        await this.syncMatchedProfileFromActiveAuth(matching, description);
+        return this.buildActiveCodexAuthStatus("matched", description, {
+          profileName: normalized
         });
-        if (scoped) {
-          const normalized = this.normalizeProfileName(scoped.name);
-          await this.persistPreferredProfileName(normalized);
-          return { name: normalized, trusted: true };
-        }
-        const matching = await this.getProfileRowByIdentityKey(activeIdentityKey, { preferAuthMethod: "codex-cli" });
-        if (matching) {
-          const normalized = this.normalizeProfileName(matching.name);
-          await this.persistPreferredProfileName(normalized);
-          return { name: normalized, trusted: true };
-        }
       }
-    }
-    const preferred = await this.readPreferredProfileName();
-    if (preferred) {
-      try {
-        const normalized = this.normalizeProfileName(preferred);
-        const exists = await this.getProfileRowByName(normalized);
-        if (exists) {
-          return { name: normalized, trusted: true };
-        }
-      } catch {
-        await this.persistPreferredProfileName(null);
-        return { name: null, trusted: false };
+      if (!options.autoImport) {
+        return this.buildActiveCodexAuthStatus("unmanaged", description);
+      }
+      if (options.canAutoImport === false) {
+        return this.buildActiveCodexAuthStatus("unmanaged", description, {
+          importBlockedReason: options.importBlockedReason ?? "Profile limit reached. Upgrade to CodexUse Pro or remove a profile before importing this Codex login."
+        });
       }
-      await this.persistPreferredProfileName(null);
+      const records = await this.listProfileRecords();
+      const profileName = this.resolveAutoImportedProfileName(description.email, records);
+      const profileData = {
+        ...description.normalized,
+        auth_method: "codex-cli",
+        created_at: description.normalized.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.persistProfileRecord(profileName, profileData, description.metadata, {
+        displayName: description.email ?? profileName
+      });
+      return this.buildActiveCodexAuthStatus("matched", description, {
+        profileName,
+        importedProfileName: profileName
+      });
+    });
+  }
+  /**
+   * Check if the real Codex auth file matches a saved profile.
+   */
+  async getCurrentProfile() {
+    const status = await this.getActiveCodexAuthStatus({ autoImport: false });
+    if (status.state === "matched" && status.profileName) {
+      return { name: status.profileName, trusted: true };
     }
     return { name: null, trusted: false };
   }
@@ -5831,17 +6142,6 @@ var ProfileManager = class {
         }
       }
     }
-    const preferred = await this.readPreferredProfileName();
-    if (preferred) {
-      try {
-        const normalizedPreferred = this.normalizeProfileName(preferred);
-        if (!normalized.has(normalizedPreferred)) {
-          await this.persistPreferredProfileName(null);
-        }
-      } catch {
-        await this.persistPreferredProfileName(null);
-      }
-    }
     return {
       imported: normalized.size,
       removed
@@ -5874,8 +6174,8 @@ Usage:
   codexuse profile current
   codexuse profile add <name> [--skip-login] [--device-auth] [--login=browser|device]
   codexuse profile refresh <name> [--skip-login] [--device-auth] [--login=browser|device]
-  codexuse profile switch <name>
-  codexuse profile autoroll [--threshold=50-100] [--dry-run] [--watch] [--interval=seconds]
+  codexuse profile switch <name> [--restart-codex]
+  codexuse profile autoroll [--switch-left=0-50] [--threshold=50-100] [--dry-run] [--watch] [--interval=seconds] [--restart-codex|--no-restart-codex]
   codexuse profile delete <name>
   codexuse profile rename <old> <new>
 
@@ -5895,22 +6195,26 @@ Flags:
   --compact        Names only
   --device-auth    Use device auth for Codex login
   --login=MODE     Login mode: browser | device
-  --threshold=NN   Auto-roll switch threshold percent (50-100)
+  --switch-left=NN Auto-roll switch threshold by percent left (0-50)
+  --threshold=NN   Legacy auto-roll switch threshold by percent used (50-100)
   --watch          Keep checking and auto-switch when threshold is reached
   --interval=SEC   Watch interval in seconds (default: 30)
   --dry-run        Print planned switch without changing active profile
+  --restart-codex  Restart official Codex after a profile switch
+  --no-restart-codex Override saved auto-roll restart setting
   --profile=NAME   Run Codex with one saved profile
   --runtime=NAME   Accounts Pool runtime store: desktop | daemon
   --state-dir=PATH Override the runtime state dir for Accounts Pool inspection
   --port=NNNN      Stable daemon/API port (or use with account-pool status for daemon base URL)
   --telegram-bot-token=TOKEN   Enable Telegram remote control for daemon mode
   --project-path=PATH          Optional path to bootstrap as the default Projects root in daemon mode
+
+Note: profile autoroll requires Pro.
 `);
 }
 
 // src/platform/args.ts
 var DEFAULT_AUTOROLL_INTERVAL_SECONDS = 30;
-var DEFAULT_AUTOROLL_THRESHOLD = 95;
 function hasFlag(args, flag) {
   return args.includes(flag);
 }
@@ -7694,6 +7998,411 @@ async function assertProfileCreationAllowed(profileManager) {
   }
 }
 
+// ../../packages/runtime-codex/src/codex/officialAppRestart.ts
+var import_node_child_process7 = require("child_process");
+var import_node_fs8 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path11 = __toESM(require("path"), 1);
+var RESTART_COOLDOWN_MS = 6e4;
+var COMMAND_TIMEOUT_MS = 3e3;
+var EXIT_WAIT_MS = 1e4;
+var LAUNCH_WAIT_MS = 15e3;
+var POLL_INTERVAL_MS = 250;
+var APP_DISCOVERY_CACHE_TTL_MS = 6e4;
+var APP_DISCOVERY_MISS_CACHE_TTL_MS = 5e3;
+var restartPromise = null;
+var lastRestartStartedAt = 0;
+var profileActionLock = Promise.resolve();
+var appDiscoveryCache = null;
+function logOfficialCodexRestart(level, message, context) {
+  const logger = level === "warn" ? console.warn : level === "error" ? console.error : console.info;
+  if (context && Object.keys(context).length > 0) {
+    logger(`[official-codex-restart] ${message}`, context);
+    return;
+  }
+  logger(`[official-codex-restart] ${message}`);
+}
+function runCommand2(command, args, timeoutMs = COMMAND_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process7.spawn)(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({
+        code: -1,
+        stdout,
+        stderr: error instanceof Error ? error.message : String(error),
+        timedOut
+      });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code, stdout, stderr, timedOut });
+    });
+  });
+}
+async function readBundleString(appPath, key) {
+  const plistPath = import_node_path11.default.join(appPath, "Contents", "Info.plist");
+  if (!(0, import_node_fs8.existsSync)(plistPath)) {
+    return null;
+  }
+  const result = await runCommand2("/usr/bin/plutil", [
+    "-extract",
+    key,
+    "raw",
+    "-o",
+    "-",
+    plistPath
+  ]);
+  if (result.code !== 0) {
+    return null;
+  }
+  const bundleId = result.stdout.trim();
+  return bundleId.length > 0 ? bundleId : null;
+}
+async function discoverCodexAppCandidates() {
+  const now = Date.now();
+  const envPath = process.env.CODEXUSE_OFFICIAL_CODEX_APP_PATH?.trim() || null;
+  if (appDiscoveryCache && appDiscoveryCache.envPath === envPath && appDiscoveryCache.expiresAt > now) {
+    return appDiscoveryCache.candidates;
+  }
+  const rawPaths = /* @__PURE__ */ new Set();
+  if (envPath) {
+    rawPaths.add(envPath);
+  }
+  rawPaths.add("/Applications/Codex.app");
+  rawPaths.add(import_node_path11.default.join((0, import_node_os5.homedir)(), "Applications", "Codex.app"));
+  const mdfind = await runCommand2(
+    "/usr/bin/mdfind",
+    ["kMDItemFSName == 'Codex.app'"],
+    1500
+  );
+  if (mdfind.code === 0) {
+    for (const line of mdfind.stdout.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed.endsWith("/Codex.app")) {
+        rawPaths.add(trimmed);
+      }
+    }
+  }
+  const candidates = [];
+  for (const appPath of rawPaths) {
+    if (!(0, import_node_fs8.existsSync)(appPath) || import_node_path11.default.basename(appPath) !== "Codex.app") {
+      continue;
+    }
+    const bundleId = await readBundleString(appPath, "CFBundleIdentifier");
+    if (!bundleId || bundleId.toLowerCase().includes("codexuse")) {
+      continue;
+    }
+    candidates.push({
+      appPath,
+      bundleId,
+      version: await readBundleString(appPath, "CFBundleShortVersionString"),
+      executableName: await readBundleString(appPath, "CFBundleExecutable") ?? "Codex"
+    });
+  }
+  const sorted = candidates.sort((a, b) => a.appPath.localeCompare(b.appPath));
+  appDiscoveryCache = {
+    envPath,
+    expiresAt: now + (sorted.length > 0 ? APP_DISCOVERY_CACHE_TTL_MS : APP_DISCOVERY_MISS_CACHE_TTL_MS),
+    candidates: sorted
+  };
+  return sorted;
+}
+async function getRunningCodexPids(candidate) {
+  const result = await runCommand2("/bin/ps", ["-axo", "pid=,args="], 2e3);
+  const pids = /* @__PURE__ */ new Set();
+  const appContentsRoot = `${import_node_path11.default.join(candidate.appPath, "Contents")}${import_node_path11.default.sep}`;
+  if (result.code === 0) {
+    for (const line of result.stdout.split(/\r?\n/)) {
+      const match = line.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) {
+        continue;
+      }
+      const pid = Number(match[1]);
+      const args = match[2] ?? "";
+      if (Number.isInteger(pid) && args.includes(appContentsRoot)) {
+        pids.add(pid);
+      }
+    }
+  }
+  return Array.from(pids).sort((a, b) => a - b);
+}
+async function getRunningCodexMainPids(candidate) {
+  const result = await runCommand2("/bin/ps", ["-axo", "pid=,args="], 2e3);
+  const pids = /* @__PURE__ */ new Set();
+  const executablePath = import_node_path11.default.join(
+    candidate.appPath,
+    "Contents",
+    "MacOS",
+    candidate.executableName
+  );
+  if (result.code === 0) {
+    for (const line of result.stdout.split(/\r?\n/)) {
+      const match = line.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) {
+        continue;
+      }
+      const pid = Number(match[1]);
+      const args = match[2] ?? "";
+      if (Number.isInteger(pid) && args.includes(executablePath)) {
+        pids.add(pid);
+      }
+    }
+  }
+  return Array.from(pids).sort((a, b) => a - b);
+}
+async function resolveCodexAppTarget() {
+  const candidates = await discoverCodexAppCandidates();
+  const fallback = candidates[0] ?? null;
+  if (!fallback) {
+    return { candidate: null, runningPids: [], mainPids: [] };
+  }
+  for (const candidate of candidates) {
+    const [runningPids2, mainPids2] = await Promise.all([
+      getRunningCodexPids(candidate),
+      getRunningCodexMainPids(candidate)
+    ]);
+    if (mainPids2.length > 0) {
+      return { candidate, runningPids: runningPids2, mainPids: mainPids2 };
+    }
+  }
+  const [runningPids, mainPids] = await Promise.all([
+    getRunningCodexPids(fallback),
+    getRunningCodexMainPids(fallback)
+  ]);
+  return { candidate: fallback, runningPids, mainPids };
+}
+async function waitForCodexExit(candidate, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const pids = await getRunningCodexPids(candidate);
+    if (pids.length === 0) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+async function signalPids(pids, signal) {
+  const signaled = [];
+  for (const pid of pids) {
+    try {
+      process.kill(pid, signal);
+      signaled.push(pid);
+    } catch {
+    }
+  }
+  return signaled;
+}
+async function openCodex(candidate) {
+  const byBundle = await runCommand2("/usr/bin/open", ["-b", candidate.bundleId]);
+  if (byBundle.code === 0) {
+    return true;
+  }
+  const byPath = await runCommand2("/usr/bin/open", [candidate.appPath]);
+  return byPath.code === 0;
+}
+async function waitForCodexLaunch(candidate) {
+  const deadline = Date.now() + LAUNCH_WAIT_MS;
+  while (Date.now() < deadline) {
+    const pids = await getRunningCodexMainPids(candidate);
+    const pid = pids[0] ?? null;
+    if (pid !== null) {
+      return pid;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return null;
+}
+async function rememberProfileSwitch(profileKey) {
+  await patchAppState({
+    officialCodex: {
+      lastProfileSwitchAt: Date.now(),
+      lastProfileSwitchProfileKey: profileKey
+    }
+  });
+}
+async function rememberRestartResult(args) {
+  const now = Date.now();
+  const verified = args.status === "restarted" || args.status === "started";
+  await patchAppState({
+    officialCodex: {
+      lastVerifiedLaunchAt: verified ? now : void 0,
+      lastVerifiedLaunchProfileKey: verified ? args.profileKey ?? null : void 0,
+      lastObservedPid: verified ? args.pid ?? null : void 0,
+      lastRestartStatus: args.status,
+      lastRestartReason: args.reason ?? null
+    }
+  });
+}
+async function restartOfficialCodexAppOnce(options) {
+  if (process.platform !== "darwin") {
+    await rememberRestartResult({ status: "skipped", reason: "unsupported-platform" });
+    return { status: "skipped", reason: "unsupported-platform" };
+  }
+  const now = Date.now();
+  if (options.source !== "manual" && lastRestartStartedAt > 0 && now - lastRestartStartedAt < RESTART_COOLDOWN_MS) {
+    await rememberRestartResult({
+      status: "skipped",
+      reason: "cooldown",
+      profileKey: options.currentProfileKey
+    });
+    return { status: "skipped", reason: "cooldown" };
+  }
+  const { candidate, runningPids, mainPids } = await resolveCodexAppTarget();
+  if (!candidate) {
+    await rememberRestartResult({
+      status: "skipped",
+      reason: "official-codex-app-not-found",
+      profileKey: options.currentProfileKey
+    });
+    return { status: "skipped", reason: "official-codex-app-not-found" };
+  }
+  const appIsRunning = mainPids.length > 0;
+  if (!appIsRunning && !options.launchIfNotRunning) {
+    await rememberRestartResult({
+      status: "skipped",
+      reason: "official-codex-app-not-running",
+      profileKey: options.currentProfileKey
+    });
+    return { status: "skipped", reason: "official-codex-app-not-running" };
+  }
+  if (options.source !== "manual") {
+    lastRestartStartedAt = Date.now();
+  }
+  if (appIsRunning) {
+    logOfficialCodexRestart("warn", "Force killing official Codex before relaunch.", {
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      source: options.source,
+      runningPids,
+      mainPids
+    });
+    const killedPids = await signalPids(runningPids, "SIGKILL");
+    logOfficialCodexRestart("warn", "Sent SIGKILL to official Codex pids.", {
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      source: options.source,
+      killedPids
+    });
+    const exited = await waitForCodexExit(candidate, EXIT_WAIT_MS);
+    if (!exited) {
+      const remainingPids = await getRunningCodexPids(candidate);
+      logOfficialCodexRestart("error", "Official Codex pids remained after force kill.", {
+        appPath: candidate.appPath,
+        bundleId: candidate.bundleId,
+        source: options.source,
+        remainingPids
+      });
+      const failed = {
+        status: "failed",
+        appPath: candidate.appPath,
+        bundleId: candidate.bundleId,
+        reason: "force-quit-timeout",
+        phase: "quit"
+      };
+      await rememberRestartResult({
+        status: failed.status,
+        reason: failed.reason,
+        profileKey: options.currentProfileKey
+      });
+      return failed;
+    }
+    logOfficialCodexRestart("info", "Official Codex exited after force kill.", {
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      source: options.source
+    });
+  }
+  const opened = await openCodex(candidate);
+  if (!opened) {
+    const failed = {
+      status: "failed",
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      reason: "open-failed",
+      phase: "launch"
+    };
+    await rememberRestartResult({
+      status: failed.status,
+      reason: failed.reason,
+      profileKey: options.currentProfileKey
+    });
+    return failed;
+  }
+  const launchedPid = await waitForCodexLaunch(candidate);
+  if (launchedPid === null) {
+    logOfficialCodexRestart("error", "Official Codex launch was not verified.", {
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      source: options.source
+    });
+    const failed = {
+      status: "failed",
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      reason: "launch-timeout",
+      phase: "launch"
+    };
+    await rememberRestartResult({
+      status: failed.status,
+      reason: failed.reason,
+      profileKey: options.currentProfileKey
+    });
+    return failed;
+  }
+  const status = appIsRunning ? "restarted" : "started";
+  logOfficialCodexRestart("info", "Official Codex launch verified.", {
+    appPath: candidate.appPath,
+    bundleId: candidate.bundleId,
+    source: options.source,
+    status,
+    pid: launchedPid
+  });
+  await rememberRestartResult({
+    status,
+    profileKey: options.currentProfileKey,
+    pid: launchedPid
+  });
+  return {
+    status,
+    appPath: candidate.appPath,
+    bundleId: candidate.bundleId,
+    pid: launchedPid
+  };
+}
+function recordOfficialCodexProfileSwitch(profileKey) {
+  return rememberProfileSwitch(profileKey);
+}
+function restartOfficialCodexApp(options = {}) {
+  if (restartPromise) {
+    return restartPromise;
+  }
+  restartPromise = restartOfficialCodexAppOnce({
+    source: options.source ?? "manual",
+    currentProfileKey: options.currentProfileKey ?? null,
+    launchIfNotRunning: options.launchIfNotRunning ?? (options.source ?? "manual") === "manual"
+  }).finally(() => {
+    restartPromise = null;
+  });
+  return restartPromise;
+}
+
 // src/commands/profile.ts
 function formatProfileLabel(name, displayName) {
   if (displayName && displayName.trim() && displayName !== name) {
@@ -7812,6 +8521,7 @@ function formatWindowUsage(window) {
 var EMPTY_USAGE_SUMMARY = {
   windowKey: "primary",
   usagePercent: 0,
+  remainingPercent: 100,
   hasUsage: false,
   resetsInSeconds: null,
   windowMinutes: null
@@ -7835,6 +8545,7 @@ function summarizeRateLimitSnapshot(snapshot) {
     }
     const usageValueRaw = toFiniteNumberOrNull(entry.window.usedPercent);
     const usageValue = usageValueRaw === null ? 0 : Math.max(0, Math.min(100, usageValueRaw));
+    const remainingValue = 100 - usageValue;
     const hasUsage = usageValueRaw !== null;
     const resetsInSeconds = toFiniteNumberOrNull(entry.window.resetsInSeconds);
     const windowMinutes = toFiniteNumberOrNull(entry.window.windowMinutes);
@@ -7843,6 +8554,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7853,6 +8565,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7864,6 +8577,7 @@ function summarizeRateLimitSnapshot(snapshot) {
         summary = {
           windowKey: entry.key,
           usagePercent: usageValue,
+          remainingPercent: remainingValue,
           hasUsage,
           resetsInSeconds,
           windowMinutes
@@ -7875,6 +8589,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7885,6 +8600,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7929,9 +8645,16 @@ async function resolveProfileUsage(manager, profile, codexPath) {
     return fallbackUsage(profile);
   }
 }
-function compareAutoRollCandidates(a, b) {
-  if (a.usageSummary.usagePercent !== b.usageSummary.usagePercent) {
-    return a.usageSummary.usagePercent - b.usageSummary.usagePercent;
+function compareAutoRollCandidates(a, b, priorityRanks) {
+  const aRank = priorityRanks.get(resolveProfileIdentityKeyFromProfile(a.profile));
+  const bRank = priorityRanks.get(resolveProfileIdentityKeyFromProfile(b.profile));
+  if (aRank !== void 0 || bRank !== void 0) {
+    if (aRank === void 0) return 1;
+    if (bRank === void 0) return -1;
+    if (aRank !== bRank) return aRank - bRank;
+  }
+  if (a.usageSummary.remainingPercent !== b.usageSummary.remainingPercent) {
+    return b.usageSummary.remainingPercent - a.usageSummary.remainingPercent;
   }
   const aReset = a.usageSummary.resetsInSeconds ?? Number.POSITIVE_INFINITY;
   const bReset = b.usageSummary.resetsInSeconds ?? Number.POSITIVE_INFINITY;
@@ -7940,37 +8663,38 @@ function compareAutoRollCandidates(a, b) {
   }
   return a.profile.name.localeCompare(b.profile.name);
 }
-function computeAutoRollCandidate(profiles, usageMap, currentProfileName, currentSummary, switchThreshold) {
-  const candidates = profiles.filter((profile) => profile.name !== currentProfileName && profile.isValid && !profile.tokenStatus?.requiresUserAction).map((profile) => ({
+function computeAutoRollCandidate(profiles, usageMap, currentProfileName, currentSummary, switchRemainingThreshold, priorityOrder = [], blockedProfileNames = /* @__PURE__ */ new Set()) {
+  const priorityRanks = /* @__PURE__ */ new Map();
+  for (const [index, key] of priorityOrder.entries()) {
+    const normalized = key.trim();
+    if (normalized && !priorityRanks.has(normalized)) {
+      priorityRanks.set(normalized, index);
+    }
+  }
+  const candidates = profiles.filter(
+    (profile) => profile.name !== currentProfileName && !blockedProfileNames.has(profile.name) && profile.isValid && !profile.tokenStatus?.requiresUserAction
+  ).map((profile) => ({
     profile,
     usageSummary: usageMap.get(profile.name)?.usageSummary ?? summarizeRateLimitSnapshot(profile.rateLimit ?? null)
   }));
   if (candidates.length === 0) {
     return null;
   }
-  const belowThreshold = candidates.filter((candidate) => candidate.usageSummary.hasUsage && candidate.usageSummary.usagePercent < switchThreshold).sort(compareAutoRollCandidates);
+  const belowThreshold = candidates.filter(
+    (candidate) => candidate.usageSummary.hasUsage && candidate.usageSummary.remainingPercent > switchRemainingThreshold
+  ).sort((a, b) => compareAutoRollCandidates(a, b, priorityRanks));
   let selected = belowThreshold[0] ?? null;
   if (!selected) {
-    selected = candidates.filter((candidate) => candidate.usageSummary.hasUsage).sort(compareAutoRollCandidates)[0] ?? null;
-  }
-  if (!selected) {
-    selected = candidates.filter((candidate) => !candidate.usageSummary.hasUsage).sort((a, b) => {
-      const aReset = a.usageSummary.resetsInSeconds ?? Number.POSITIVE_INFINITY;
-      const bReset = b.usageSummary.resetsInSeconds ?? Number.POSITIVE_INFINITY;
-      if (aReset !== bReset) {
-        return aReset - bReset;
-      }
-      return a.profile.name.localeCompare(b.profile.name);
-    })[0] ?? null;
+    selected = candidates.filter((candidate) => !candidate.usageSummary.hasUsage).sort((a, b) => compareAutoRollCandidates(a, b, priorityRanks))[0] ?? null;
   }
   if (!selected) {
     return null;
   }
   if (selected.usageSummary.hasUsage && currentSummary.hasUsage) {
-    if (selected.usageSummary.usagePercent > currentSummary.usagePercent) {
+    if (selected.usageSummary.remainingPercent < currentSummary.remainingPercent) {
       return null;
     }
-    if (selected.usageSummary.usagePercent === currentSummary.usagePercent) {
+    if (selected.usageSummary.remainingPercent === currentSummary.remainingPercent) {
       const selectedReset = selected.usageSummary.resetsInSeconds ?? Number.POSITIVE_INFINITY;
       const currentReset = currentSummary.resetsInSeconds ?? Number.POSITIVE_INFINITY;
       if (selectedReset >= currentReset) {
@@ -8054,18 +8778,31 @@ async function mapWithConcurrency(items, limit, fn) {
   await Promise.all(workers);
   return results;
 }
-function parseAutoRollThreshold(flags, fallbackThreshold) {
-  const explicitThreshold = parseNumericFlag(flags, "--threshold");
-  if (explicitThreshold === null) {
-    return fallbackThreshold;
+function parseAutoRollSwitchRemainingThreshold(flags, fallbackThreshold) {
+  const explicitLeft = parseNumericFlag(flags, "--switch-left");
+  const explicitLegacyUsed = parseNumericFlag(flags, "--threshold");
+  if (explicitLeft !== null && explicitLegacyUsed !== null) {
+    throw new Error("Use either --switch-left or legacy --threshold, not both.");
   }
-  if (Number.isNaN(explicitThreshold)) {
-    throw new Error("Invalid --threshold value. Use --threshold=50-100.");
+  if (explicitLeft !== null) {
+    if (Number.isNaN(explicitLeft)) {
+      throw new Error("Invalid --switch-left value. Use --switch-left=0-50.");
+    }
+    if (explicitLeft < AUTO_ROLL_SWITCH_REMAINING_MIN || explicitLeft > AUTO_ROLL_SWITCH_REMAINING_MAX) {
+      throw new Error("Invalid --switch-left value. Use a number between 0 and 50.");
+    }
+    return sanitizeAutoRollSwitchRemainingThreshold(explicitLeft);
   }
-  if (explicitThreshold < 50 || explicitThreshold > 100) {
-    throw new Error("Invalid --threshold value. Use a number between 50 and 100.");
+  if (explicitLegacyUsed !== null) {
+    if (Number.isNaN(explicitLegacyUsed)) {
+      throw new Error("Invalid --threshold value. Use --threshold=50-100.");
+    }
+    if (explicitLegacyUsed < 50 || explicitLegacyUsed > 100) {
+      throw new Error("Invalid --threshold value. Use a number between 50 and 100.");
+    }
+    return sanitizeAutoRollSwitchRemainingThreshold(100 - explicitLegacyUsed);
   }
-  return Math.round(explicitThreshold);
+  return sanitizeAutoRollSwitchRemainingThreshold(fallbackThreshold);
 }
 function parseAutoRollIntervalSeconds(flags) {
   const explicitInterval = parseIntegerFlag(flags, "--interval");
@@ -8077,6 +8814,74 @@ function parseAutoRollIntervalSeconds(flags) {
   }
   return explicitInterval;
 }
+function resolveRestartCodexFlag(flags, fallback) {
+  const restart = hasFlag(flags, "--restart-codex");
+  const noRestart = hasFlag(flags, "--no-restart-codex");
+  if (restart && noRestart) {
+    throw new Error("Use either --restart-codex or --no-restart-codex, not both.");
+  }
+  if (restart) {
+    return true;
+  }
+  if (noRestart) {
+    return false;
+  }
+  return fallback;
+}
+function findProfileKey(profiles, name) {
+  const profile = profiles.find((entry) => entry.name === name);
+  return profile ? profileRateLimitKey(profile) : null;
+}
+function rearmBlockedProfiles(blockedProfiles, usageMap, rearmRemainingThreshold) {
+  if (!blockedProfiles) {
+    return;
+  }
+  for (const profileName of Array.from(blockedProfiles)) {
+    const summary = usageMap.get(profileName)?.usageSummary;
+    if (!summary || !summary.hasUsage || summary.remainingPercent > rearmRemainingThreshold) {
+      blockedProfiles.delete(profileName);
+    }
+  }
+}
+async function rememberOfficialCodexSwitch(profileKey) {
+  try {
+    await recordOfficialCodexProfileSwitch(profileKey);
+  } catch (error) {
+    console.warn(
+      `Could not record official Codex sync state: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function formatOfficialCodexRestart(result) {
+  if (result.status === "restarted") {
+    return "Official Codex restarted.";
+  }
+  if (result.status === "started") {
+    return "Official Codex started.";
+  }
+  if (result.status === "failed") {
+    return `Official Codex restart failed: ${result.reason}.`;
+  }
+  if (result.status === "skipped") {
+    return `Official Codex restart skipped: ${result.reason}.`;
+  }
+  return "Official Codex restart status unknown.";
+}
+async function maybeRestartOfficialCodex(options) {
+  if (!options.enabled) {
+    return null;
+  }
+  try {
+    const result = await restartOfficialCodexApp({
+      source: options.source,
+      currentProfileKey: options.profileKey,
+      launchIfNotRunning: options.launchIfNotRunning
+    });
+    return formatOfficialCodexRestart(result);
+  } catch (error) {
+    return `Official Codex restart failed: ${error instanceof Error ? error.message : String(error)}.`;
+  }
+}
 async function collectUsageMap(manager, profiles, codexPath) {
   const usageMap = /* @__PURE__ */ new Map();
   const uniqueProfilesByAccount = /* @__PURE__ */ new Map();
@@ -8126,6 +8931,11 @@ async function runAutoRollPass(manager, options) {
     throw new Error("Codex CLI binary not found on PATH. Auto-roll requires codex for live rate limits.");
   }
   const usageMap = await collectUsageMap(manager, profiles, codexPath);
+  rearmBlockedProfiles(
+    options.blockedProfiles,
+    usageMap,
+    options.rearmRemainingThreshold
+  );
   const currentProfile = profiles.find((profile) => profile.name === current.name);
   if (!currentProfile) {
     return {
@@ -8144,10 +8954,31 @@ async function runAutoRollPass(manager, options) {
       target: null
     };
   }
-  if (currentUsage.usagePercent < options.threshold) {
+  if (options.blockedProfiles?.has(current.name)) {
+    if (currentUsage.remainingPercent > options.rearmRemainingThreshold) {
+      options.blockedProfiles.delete(current.name);
+    } else {
+      return {
+        switched: false,
+        message: `'${current.name}' at ${Math.round(currentUsage.remainingPercent)}% left; waiting for re-arm above ${options.rearmRemainingThreshold}% left.`,
+        source: current.name,
+        target: null
+      };
+    }
+  }
+  if (options.blockCurrentUntilRearm && currentUsage.remainingPercent <= options.switchRemainingThreshold) {
+    options.blockedProfiles?.add(current.name);
+    return {
+      switched: false,
+      message: `'${current.name}' at ${Math.round(currentUsage.remainingPercent)}% left; waiting for re-arm above ${options.rearmRemainingThreshold}% left.`,
+      source: current.name,
+      target: null
+    };
+  }
+  if (currentUsage.remainingPercent > options.switchRemainingThreshold) {
     return {
       switched: false,
-      message: `'${current.name}' at ${Math.round(currentUsage.usagePercent)}%, below threshold ${options.threshold}%.`,
+      message: `'${current.name}' at ${Math.round(currentUsage.remainingPercent)}% left, above switch threshold ${options.switchRemainingThreshold}% left.`,
       source: current.name,
       target: null
     };
@@ -8157,29 +8988,41 @@ async function runAutoRollPass(manager, options) {
     usageMap,
     current.name,
     currentUsage,
-    options.threshold
+    options.switchRemainingThreshold,
+    options.priorityOrder ?? [],
+    options.blockedProfiles
   );
   if (!candidate) {
     return {
       switched: false,
-      message: `No eligible profile to switch from '${current.name}' at ${Math.round(currentUsage.usagePercent)}%.`,
+      message: `No eligible profile to switch from '${current.name}' at ${Math.round(currentUsage.remainingPercent)}% left.`,
       source: current.name,
       target: null
     };
   }
-  const candidateUsage = candidate.usageSummary.hasUsage ? `${Math.round(candidate.usageSummary.usagePercent)}%` : "n/a";
+  const candidateUsage = candidate.usageSummary.hasUsage ? `${Math.round(candidate.usageSummary.remainingPercent)}% left` : "n/a";
   if (options.dryRun) {
+    const restartSuffix = options.restartOfficialCodex ? " Official Codex would restart after the switch if running." : "";
     return {
       switched: false,
-      message: `[dry-run] Would switch '${current.name}' (${Math.round(currentUsage.usagePercent)}%) -> '${candidate.profile.name}' (${candidateUsage}).`,
+      message: `[dry-run] Would switch '${current.name}' (${Math.round(currentUsage.remainingPercent)}% left) -> '${candidate.profile.name}' (${candidateUsage}).${restartSuffix}`,
       source: current.name,
       target: candidate.profile.name
     };
   }
   await manager.switchToProfile(candidate.profile.name);
+  const targetProfileKey = profileRateLimitKey(candidate.profile);
+  await rememberOfficialCodexSwitch(targetProfileKey);
+  const restartMessage = await maybeRestartOfficialCodex({
+    enabled: options.restartOfficialCodex,
+    source: "auto-roll",
+    profileKey: targetProfileKey,
+    launchIfNotRunning: options.launchOfficialCodexWhenClosed === true
+  });
+  options.blockedProfiles?.add(current.name);
   return {
     switched: true,
-    message: `Auto-rolled '${current.name}' (${Math.round(currentUsage.usagePercent)}%) -> '${candidate.profile.name}' (${candidateUsage}).`,
+    message: `Auto-rolled '${current.name}' (${Math.round(currentUsage.remainingPercent)}% left) -> '${candidate.profile.name}' (${candidateUsage}).${restartMessage ? ` ${restartMessage}` : ""}`,
     source: current.name,
     target: candidate.profile.name
   };
@@ -8279,20 +9122,51 @@ async function handleProfileCommand(args, version) {
       if (!name) {
         throw new Error("Profile name is required.");
       }
+      const restartOfficialCodex = resolveRestartCodexFlag(flags, false);
+      const profiles = await manager.listProfiles();
+      const targetProfileKey = findProfileKey(profiles, name);
       await manager.switchToProfile(name);
       console.log(`Switched to profile: ${name}`);
+      await rememberOfficialCodexSwitch(targetProfileKey);
+      const restartMessage = await maybeRestartOfficialCodex({
+        enabled: restartOfficialCodex,
+        source: "manual",
+        profileKey: targetProfileKey
+      });
+      if (restartMessage) {
+        console.log(restartMessage);
+      }
       return;
     }
     case "autoroll":
     case "auto-roll": {
+      const license = await licenseService.getStatus();
+      if (!license.isPro) {
+        throw new Error("Auto-roll requires a Pro license.");
+      }
       const watch = hasFlag(flags, "--watch");
       const dryRun = hasFlag(flags, "--dry-run");
       const settings = await getStoredAutoRollSettings().catch(() => null);
-      const fallbackThreshold = typeof settings?.switchThreshold === "number" && Number.isFinite(settings.switchThreshold) ? Math.round(settings.switchThreshold) : DEFAULT_AUTOROLL_THRESHOLD;
-      const threshold = parseAutoRollThreshold(flags, fallbackThreshold);
+      const restartOfficialCodex = resolveRestartCodexFlag(
+        flags,
+        settings?.restartOfficialCodexOnAutoRoll === true
+      );
+      const fallbackSwitchRemainingThreshold = typeof settings?.switchRemainingThreshold === "number" && Number.isFinite(settings.switchRemainingThreshold) ? settings.switchRemainingThreshold : DEFAULT_AUTO_ROLL_SWITCH_REMAINING_THRESHOLD;
+      const switchRemainingThreshold = parseAutoRollSwitchRemainingThreshold(
+        flags,
+        fallbackSwitchRemainingThreshold
+      );
+      const rearmRemainingThreshold = sanitizeAutoRollRearmRemainingThreshold(
+        settings?.rearmRemainingThreshold ?? DEFAULT_AUTO_ROLL_REARM_REMAINING_THRESHOLD,
+        switchRemainingThreshold
+      );
       const intervalSeconds = parseAutoRollIntervalSeconds(flags);
       if (watch) {
-        console.log(`Auto-roll watch: threshold ${threshold}% | interval ${intervalSeconds}s${dryRun ? " | dry-run" : ""}`);
+        console.log(
+          `Auto-roll watch: switch at/below ${switchRemainingThreshold}% left | re-arm above ${rearmRemainingThreshold}% left | interval ${intervalSeconds}s${dryRun ? " | dry-run" : ""}${restartOfficialCodex ? " | restart-codex" : ""}`
+        );
+        const blockedProfiles = /* @__PURE__ */ new Set();
+        let lastObservedProfile = null;
         let stop = false;
         process.on("SIGINT", () => {
           stop = true;
@@ -8301,8 +9175,23 @@ async function handleProfileCommand(args, version) {
           stop = true;
         });
         while (!stop) {
-          const result2 = await runAutoRollPass(manager, { threshold, dryRun });
+          const current = await manager.getCurrentProfile();
+          const currentName = current.name ?? null;
+          const blockCurrentUntilRearm = Boolean(
+            currentName && lastObservedProfile && currentName !== lastObservedProfile
+          );
+          const result2 = await runAutoRollPass(manager, {
+            switchRemainingThreshold,
+            rearmRemainingThreshold,
+            dryRun,
+            priorityOrder: settings?.priorityOrder ?? [],
+            restartOfficialCodex,
+            launchOfficialCodexWhenClosed: settings?.launchOfficialCodexWhenClosedOnAutoRoll === true,
+            blockedProfiles,
+            blockCurrentUntilRearm
+          });
           console.log(result2.message);
+          lastObservedProfile = result2.switched ? result2.target ?? currentName : currentName ?? result2.source;
           if (stop) {
             break;
           }
@@ -8311,7 +9200,14 @@ async function handleProfileCommand(args, version) {
         console.log("Auto-roll watch stopped.");
         return;
       }
-      const result = await runAutoRollPass(manager, { threshold, dryRun });
+      const result = await runAutoRollPass(manager, {
+        switchRemainingThreshold,
+        rearmRemainingThreshold,
+        dryRun,
+        priorityOrder: settings?.priorityOrder ?? [],
+        restartOfficialCodex,
+        launchOfficialCodexWhenClosed: settings?.launchOfficialCodexWhenClosedOnAutoRoll === true
+      });
       console.log(result.message);
       return;
     }
@@ -8341,8 +9237,8 @@ async function handleProfileCommand(args, version) {
 }
 
 // ../../packages/runtime-profiles/src/cloud-sync/service.ts
-var import_node_fs8 = require("fs");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var import_node_path15 = __toESM(require("path"), 1);
 
 // ../../packages/contracts/src/cloud-sync/types.ts
 var CLOUD_SYNC_SCHEMA_VERSION = 1;
@@ -8502,9 +9398,9 @@ async function pushRemoteSnapshot(licenseKey, snapshot, options) {
 var import_toml2 = __toESM(require_toml(), 1);
 
 // ../../packages/runtime-codex/src/codex/config-metadata.ts
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 var import_promises = require("fs/promises");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __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 = [
@@ -8612,9 +9508,9 @@ function isRecord5(value) {
 function uniqueSorted(values) {
   return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
 }
-async function runCommand2(command, args, timeoutMs = 3e3) {
+async function runCommand3(command, args, timeoutMs = 3e3) {
   return new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process7.spawn)(command, args, {
+    const child = (0, import_node_child_process8.spawn)(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
     });
@@ -8649,7 +9545,7 @@ async function runCodexCommand(args) {
   const isJsLauncher = codexPath.endsWith(".js");
   const command = isJsLauncher ? process.execPath : codexPath;
   const commandArgs = isJsLauncher ? [codexPath, ...args] : args;
-  return runCommand2(command, commandArgs);
+  return runCommand3(command, commandArgs);
 }
 function parseFeatureCatalog(output) {
   const entries = [];
@@ -8690,8 +9586,8 @@ function parseSchemaKeys(schemaRaw) {
 async function readSchemaFromLocal() {
   const candidates = [
     process.env.CODEX_CONFIG_SCHEMA_PATH,
-    import_node_path11.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
-    import_node_path11.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
+    import_node_path12.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
+    import_node_path12.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
     try {
@@ -8796,20 +9692,20 @@ async function getCodexConfigMetadata(forceRefresh = false) {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 var import_promises2 = require("fs/promises");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/home.ts
-var import_node_os5 = __toESM(require("os"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_os6 = __toESM(require("os"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 function resolveHomeDir() {
-  return process.env.HOME || process.env.USERPROFILE || import_node_os5.default.homedir();
+  return process.env.HOME || process.env.USERPROFILE || import_node_os6.default.homedir();
 }
 function expandHomePrefix(input, homeDir) {
   if (input === "~") {
     return homeDir;
   }
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return import_node_path12.default.join(homeDir, input.slice(2));
+    return import_node_path13.default.join(homeDir, input.slice(2));
   }
   return input;
 }
@@ -8825,13 +9721,10 @@ function normalizeCodexHomePath(input) {
   if (!configured) {
     return null;
   }
-  return import_node_path12.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
+  return import_node_path13.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
 }
 function resolveDefaultCodexHomeDir() {
-  return import_node_path12.default.join(resolveHomeDir(), ".codex");
-}
-function resolveProfileCodexHomeDir(profileName) {
-  return import_node_path12.default.join(getUserDataDir(), "profile-homes", profileName);
+  return import_node_path13.default.join(resolveHomeDir(), ".codex");
 }
 function resolveCodexHomeDir(options) {
   return normalizeCodexHomePath(options?.codexHomePath) ?? resolveDefaultCodexHomeDir();
@@ -8846,14 +9739,6 @@ async function resolveCodexRuntimeContext(options) {
     };
   }
   const state = await getAppState();
-  const profileName = normalizePathCandidate(state.app.lastProfileName);
-  if (profileName && state.profilesByName[profileName]) {
-    return {
-      codexHomePath: resolveProfileCodexHomeDir(profileName),
-      profileName,
-      source: "profile"
-    };
-  }
   const configured = normalizeCodexHomePath(
     state.runtimeSettings?.codexHome
   );
@@ -8912,10 +9797,10 @@ var YOLO_PRESET = {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 function getConfigPath(options) {
-  return import_node_path13.default.join(resolveCodexHomeDir(options), "config.toml");
+  return import_node_path14.default.join(resolveCodexHomeDir(options), "config.toml");
 }
 async function ensureConfigDirExists(filePath) {
-  const dir = import_node_path13.default.dirname(filePath);
+  const dir = import_node_path14.default.dirname(filePath);
   await (0, import_promises2.mkdir)(dir, { recursive: true });
 }
 function normalizeLineEndings2(content) {
@@ -9569,13 +10454,13 @@ function formatMegabytes(bytes) {
   return (bytes / MB_DIVISOR).toFixed(2);
 }
 function resolveSyncBackupsDir() {
-  return import_node_path14.default.join(getUserDataDir(), SYNC_BACKUP_DIR);
+  return import_node_path15.default.join(getUserDataDir(), SYNC_BACKUP_DIR);
 }
 function toSafeIsoForFileName(iso) {
   return iso.replace(/:/g, "-");
 }
 async function pruneOldPrePullBackups(backupsDir) {
-  const entries = await import_node_fs8.promises.readdir(backupsDir, { withFileTypes: true });
+  const entries = await import_node_fs9.promises.readdir(backupsDir, { withFileTypes: true });
   const files = entries.filter(
     (entry) => entry.isFile() && entry.name.startsWith(PRE_PULL_BACKUP_PREFIX) && entry.name.endsWith(PRE_PULL_BACKUP_SUFFIX)
   ).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
@@ -9583,7 +10468,7 @@ async function pruneOldPrePullBackups(backupsDir) {
     return;
   }
   for (const stale of files.slice(PRE_PULL_BACKUP_KEEP_COUNT)) {
-    await import_node_fs8.promises.rm(import_node_path14.default.join(backupsDir, stale), { force: true });
+    await import_node_fs9.promises.rm(import_node_path15.default.join(backupsDir, stale), { force: true });
   }
 }
 async function createPrePullBackup(profileManager) {
@@ -9591,13 +10476,13 @@ async function createPrePullBackup(profileManager) {
     enforcePushGuards: false
   });
   const backupsDir = resolveSyncBackupsDir();
-  await import_node_fs8.promises.mkdir(backupsDir, { recursive: true });
+  await import_node_fs9.promises.mkdir(backupsDir, { recursive: true });
   const timestamp = toSafeIsoForFileName((/* @__PURE__ */ new Date()).toISOString());
-  const backupPath = import_node_path14.default.join(
+  const backupPath = import_node_path15.default.join(
     backupsDir,
     `${PRE_PULL_BACKUP_PREFIX}${timestamp}${PRE_PULL_BACKUP_SUFFIX}`
   );
-  await import_node_fs8.promises.writeFile(backupPath, `${JSON.stringify(snapshot, null, 2)}
+  await import_node_fs9.promises.writeFile(backupPath, `${JSON.stringify(snapshot, null, 2)}
 `, "utf8");
   await pruneOldPrePullBackups(backupsDir);
   logInfo("[cloud-sync] created pre-pull backup", { backupPath });
@@ -9866,9 +10751,9 @@ async function handleSync(args, version) {
 }
 
 // ../../packages/runtime-app-state/src/storage/migrations/v1.ts
-var import_node_fs9 = require("fs");
-var import_node_path15 = __toESM(require("path"), 1);
-var import_node_os6 = __toESM(require("os"), 1);
+var import_node_fs10 = require("fs");
+var import_node_path16 = __toESM(require("path"), 1);
+var import_node_os7 = __toESM(require("os"), 1);
 
 // ../../packages/contracts/src/settings/legacy-localstorage-keys.ts
 var LEGACY_LOCALSTORAGE_KEYS = [
@@ -9907,20 +10792,20 @@ function isMissingPathError(error) {
   return error.code === "ENOENT";
 }
 function resolveHomeDir2() {
-  const home = process.env.HOME || process.env.USERPROFILE || import_node_os6.default.homedir();
+  const home = process.env.HOME || process.env.USERPROFILE || import_node_os7.default.homedir();
   if (!home) {
     throw new Error("HOME is not set.");
   }
   return home;
 }
 function resolveCodexDir() {
-  return import_node_path15.default.join(resolveHomeDir2(), ".codex");
+  return import_node_path16.default.join(resolveHomeDir2(), ".codex");
 }
 function resolveLegacyPath(...segments) {
-  return import_node_path15.default.join(resolveCodexDir(), ...segments);
+  return import_node_path16.default.join(resolveCodexDir(), ...segments);
 }
 async function readJsonFile(filePath) {
-  const raw = await import_node_fs9.promises.readFile(filePath, "utf8");
+  const raw = await import_node_fs10.promises.readFile(filePath, "utf8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(filePath) {
@@ -9935,14 +10820,14 @@ async function readJsonFileIfExists(filePath) {
   }
 }
 async function copyDirectoryManual(source, destination) {
-  await import_node_fs9.promises.mkdir(destination, { recursive: true });
-  const entries = await import_node_fs9.promises.readdir(source, { withFileTypes: true });
+  await import_node_fs10.promises.mkdir(destination, { recursive: true });
+  const entries = await import_node_fs10.promises.readdir(source, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_node_path15.default.join(source, entry.name);
-    const destPath = import_node_path15.default.join(destination, entry.name);
+    const srcPath = import_node_path16.default.join(source, entry.name);
+    const destPath = import_node_path16.default.join(destination, entry.name);
     if (entry.isSymbolicLink()) {
-      const linkTarget = await import_node_fs9.promises.readlink(srcPath);
-      await import_node_fs9.promises.symlink(linkTarget, destPath).catch((error) => {
+      const linkTarget = await import_node_fs10.promises.readlink(srcPath);
+      await import_node_fs10.promises.symlink(linkTarget, destPath).catch((error) => {
         if (error.code !== "EEXIST") {
           throw error;
         }
@@ -9954,14 +10839,14 @@ async function copyDirectoryManual(source, destination) {
       continue;
     }
     if (entry.isFile()) {
-      await import_node_fs9.promises.copyFile(srcPath, destPath);
+      await import_node_fs10.promises.copyFile(srcPath, destPath);
     }
   }
 }
 async function copyDirIfExists(source, destination) {
   let stats = null;
   try {
-    stats = await import_node_fs9.promises.stat(source);
+    stats = await import_node_fs10.promises.stat(source);
   } catch (error) {
     if (error.code === "ENOENT") {
       return;
@@ -9971,10 +10856,10 @@ async function copyDirIfExists(source, destination) {
   if (!stats.isDirectory()) {
     return;
   }
-  await import_node_fs9.promises.rm(destination, { recursive: true, force: true });
-  await import_node_fs9.promises.mkdir(import_node_path15.default.dirname(destination), { recursive: true });
+  await import_node_fs10.promises.rm(destination, { recursive: true, force: true });
+  await import_node_fs10.promises.mkdir(import_node_path16.default.dirname(destination), { recursive: true });
   try {
-    await import_node_fs9.promises.cp(source, destination, {
+    await import_node_fs10.promises.cp(source, destination, {
       recursive: true,
       errorOnExist: false,
       force: true,
@@ -9991,7 +10876,7 @@ async function copyDirIfExists(source, destination) {
 }
 async function copyFileIfExists(source, destination, options) {
   try {
-    const sourceStat = await import_node_fs9.promises.stat(source);
+    const sourceStat = await import_node_fs10.promises.stat(source);
     if (!sourceStat.isFile()) {
       return;
     }
@@ -10002,7 +10887,7 @@ async function copyFileIfExists(source, destination, options) {
     throw error;
   }
   try {
-    const destinationStat = await import_node_fs9.promises.stat(destination);
+    const destinationStat = await import_node_fs10.promises.stat(destination);
     if (destinationStat.isFile()) {
       return;
     }
@@ -10011,17 +10896,17 @@ async function copyFileIfExists(source, destination, options) {
       throw error;
     }
   }
-  await import_node_fs9.promises.mkdir(import_node_path15.default.dirname(destination), { recursive: true });
-  await import_node_fs9.promises.copyFile(source, destination);
+  await import_node_fs10.promises.mkdir(import_node_path16.default.dirname(destination), { recursive: true });
+  await import_node_fs10.promises.copyFile(source, destination);
   if (typeof options?.mode === "number") {
-    await import_node_fs9.promises.chmod(destination, options.mode).catch(() => void 0);
+    await import_node_fs10.promises.chmod(destination, options.mode).catch(() => void 0);
   }
 }
 async function cleanupCopiedSkillsMetadata(skillsDir) {
-  await removeIfExists(import_node_path15.default.join(skillsDir, LEGACY_SKILLS_REPOS_FILE));
+  await removeIfExists(import_node_path16.default.join(skillsDir, LEGACY_SKILLS_REPOS_FILE));
   let entries = [];
   try {
-    entries = await import_node_fs9.promises.readdir(skillsDir, { withFileTypes: true });
+    entries = await import_node_fs10.promises.readdir(skillsDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -10029,30 +10914,30 @@ async function cleanupCopiedSkillsMetadata(skillsDir) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) {
       continue;
     }
-    await removeIfExists(import_node_path15.default.join(skillsDir, entry.name, LEGACY_SKILL_MANIFEST));
+    await removeIfExists(import_node_path16.default.join(skillsDir, entry.name, LEGACY_SKILL_MANIFEST));
   }
 }
 async function migrateLegacyDirectoriesToUserData() {
   const userDataDir = getUserDataDir();
   const legacyCodexDir = resolveCodexDir();
   await copyDirIfExists(
-    import_node_path15.default.join(legacyCodexDir, LEGACY_PROFILE_HOMES_DIR),
-    import_node_path15.default.join(userDataDir, LEGACY_PROFILE_HOMES_DIR)
+    import_node_path16.default.join(legacyCodexDir, LEGACY_PROFILE_HOMES_DIR),
+    import_node_path16.default.join(userDataDir, LEGACY_PROFILE_HOMES_DIR)
   );
   await copyDirIfExists(
-    import_node_path15.default.join(legacyCodexDir, LEGACY_SKILLS_DIR),
-    import_node_path15.default.join(userDataDir, LEGACY_SKILLS_DIR)
+    import_node_path16.default.join(legacyCodexDir, LEGACY_SKILLS_DIR),
+    import_node_path16.default.join(userDataDir, LEGACY_SKILLS_DIR)
   );
   await copyDirIfExists(
-    import_node_path15.default.join(legacyCodexDir, LEGACY_SKILL_CACHE_DIR),
-    import_node_path15.default.join(userDataDir, LEGACY_SKILL_CACHE_DIR)
+    import_node_path16.default.join(legacyCodexDir, LEGACY_SKILL_CACHE_DIR),
+    import_node_path16.default.join(userDataDir, LEGACY_SKILL_CACHE_DIR)
   );
   await copyFileIfExists(
-    import_node_path15.default.join(legacyCodexDir, LEGACY_LICENSE_SECRET_FILE2),
-    import_node_path15.default.join(userDataDir, LEGACY_LICENSE_SECRET_FILE2),
+    import_node_path16.default.join(legacyCodexDir, LEGACY_LICENSE_SECRET_FILE2),
+    import_node_path16.default.join(userDataDir, LEGACY_LICENSE_SECRET_FILE2),
     { mode: 384 }
   );
-  await cleanupCopiedSkillsMetadata(import_node_path15.default.join(userDataDir, LEGACY_SKILLS_DIR));
+  await cleanupCopiedSkillsMetadata(import_node_path16.default.join(userDataDir, LEGACY_SKILLS_DIR));
 }
 function pickAutoRoll(raw) {
   if (!raw) {
@@ -10137,9 +11022,13 @@ async function loadLegacySettingsPatch() {
     license,
     autoRoll: autoRoll ? {
       enabled: autoRoll.enabled,
-      warningThreshold: autoRoll.warningThreshold,
-      switchThreshold: autoRoll.switchThreshold,
-      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll
+      rearmRemainingThreshold: autoRoll.rearmRemainingThreshold,
+      switchRemainingThreshold: autoRoll.switchRemainingThreshold,
+      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll,
+      launchOfficialCodexWhenClosedOnAutoRoll: autoRoll.launchOfficialCodexWhenClosedOnAutoRoll,
+      priorityOrder: autoRoll.priorityOrder,
+      lowRemainingNotificationEnabled: autoRoll.lowRemainingNotificationEnabled,
+      lowRemainingNotificationThreshold: autoRoll.lowRemainingNotificationThreshold
     } : void 0
   };
 }
@@ -10159,7 +11048,7 @@ async function loadLegacySyncPatch() {
   };
 }
 async function loadLegacyAppSettingsParityPatch() {
-  const filePath = import_node_path15.default.join(getUserDataDir(), LEGACY_APP_SETTINGS_PARITY_FILE);
+  const filePath = import_node_path16.default.join(getUserDataDir(), LEGACY_APP_SETTINGS_PARITY_FILE);
   const raw = await readJsonFileIfExists(filePath);
   if (!isRecord6(raw)) {
     return {};
@@ -10172,7 +11061,7 @@ async function loadLegacyProfilesPatch() {
   const root = resolveLegacyPath(LEGACY_PROFILE_HOMES_DIR);
   let entries = [];
   try {
-    entries = await import_node_fs9.promises.readdir(root, { withFileTypes: true });
+    entries = await import_node_fs10.promises.readdir(root, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") {
       return {};
@@ -10184,7 +11073,7 @@ async function loadLegacyProfilesPatch() {
     if (!entry.isDirectory() || entry.name.startsWith(".")) {
       continue;
     }
-    const profileFile = import_node_path15.default.join(root, entry.name, "profile.json");
+    const profileFile = import_node_path16.default.join(root, entry.name, "profile.json");
     const raw = await readJsonFileIfExists(profileFile);
     if (!raw) {
       continue;
@@ -10220,12 +11109,12 @@ function parseSkillInstallMetadata(raw) {
 }
 async function loadLegacySkillsPatch() {
   const skillsRoot = resolveLegacyPath(LEGACY_SKILLS_DIR);
-  const reposPath = import_node_path15.default.join(skillsRoot, LEGACY_SKILLS_REPOS_FILE);
+  const reposPath = import_node_path16.default.join(skillsRoot, LEGACY_SKILLS_REPOS_FILE);
   const reposRaw = await readJsonFileIfExists(reposPath);
   const installsBySlug = {};
   let dirEntries = [];
   try {
-    dirEntries = await import_node_fs9.promises.readdir(skillsRoot, { withFileTypes: true });
+    dirEntries = await import_node_fs10.promises.readdir(skillsRoot, { withFileTypes: true });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -10238,7 +11127,7 @@ async function loadLegacySkillsPatch() {
     if (entry.name.startsWith(".")) {
       continue;
     }
-    const manifestPath = import_node_path15.default.join(skillsRoot, entry.name, LEGACY_SKILL_MANIFEST);
+    const manifestPath = import_node_path16.default.join(skillsRoot, entry.name, LEGACY_SKILL_MANIFEST);
     const manifestRaw = await readJsonFileIfExists(manifestPath);
     const parsed = parseSkillInstallMetadata(manifestRaw);
     if (!parsed) {
@@ -10334,9 +11223,13 @@ function mergeLegacyLocalStoragePatch(payload) {
   if (autoRoll) {
     patch.autoRoll = {
       enabled: autoRoll.enabled,
-      warningThreshold: autoRoll.warningThreshold,
-      switchThreshold: autoRoll.switchThreshold,
-      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll
+      rearmRemainingThreshold: autoRoll.rearmRemainingThreshold,
+      switchRemainingThreshold: autoRoll.switchRemainingThreshold,
+      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll,
+      launchOfficialCodexWhenClosedOnAutoRoll: autoRoll.launchOfficialCodexWhenClosedOnAutoRoll,
+      priorityOrder: autoRoll.priorityOrder,
+      lowRemainingNotificationEnabled: autoRoll.lowRemainingNotificationEnabled,
+      lowRemainingNotificationThreshold: autoRoll.lowRemainingNotificationThreshold
     };
     markSkippedIfPresent("codex:auto-roll-settings", true);
   } else {
@@ -10349,13 +11242,13 @@ function mergeLegacyLocalStoragePatch(payload) {
   };
 }
 async function removeIfExists(target) {
-  await import_node_fs9.promises.rm(target, { recursive: true, force: true });
+  await import_node_fs10.promises.rm(target, { recursive: true, force: true });
 }
 async function cleanupLegacyCanonicalSources() {
   const homeDir = resolveHomeDir2();
   await removeIfExists(resolveLegacyAppStatePath());
-  await removeIfExists(import_node_path15.default.join(getUserDataDir(), LEGACY_APP_SETTINGS_PARITY_FILE));
-  await removeIfExists(import_node_path15.default.join(homeDir, SQLITE_STORAGE_DIR));
+  await removeIfExists(import_node_path16.default.join(getUserDataDir(), LEGACY_APP_SETTINGS_PARITY_FILE));
+  await removeIfExists(import_node_path16.default.join(homeDir, SQLITE_STORAGE_DIR));
   await removeIfExists(resolveLegacyPath(LEGACY_SETTINGS_FILE));
   await removeIfExists(resolveLegacyPath(LEGACY_SETTINGS_BACKUP_FILE));
   await removeIfExists(resolveLegacyPath(LEGACY_SYNC_STATE_FILE));
@@ -10363,15 +11256,15 @@ async function cleanupLegacyCanonicalSources() {
   await removeIfExists(resolveLegacyPath(LEGACY_SKILLS_DIR, LEGACY_SKILLS_REPOS_FILE));
   const profileHomesRoot = resolveLegacyPath(LEGACY_PROFILE_HOMES_DIR);
   try {
-    const profileHomes = await import_node_fs9.promises.readdir(profileHomesRoot, { withFileTypes: true });
+    const profileHomes = await import_node_fs10.promises.readdir(profileHomesRoot, { withFileTypes: true });
     for (const profileHome of profileHomes) {
       if (!profileHome.isDirectory()) {
         continue;
       }
-      const profileDir = import_node_path15.default.join(profileHomesRoot, profileHome.name);
+      const profileDir = import_node_path16.default.join(profileHomesRoot, profileHome.name);
       let files = [];
       try {
-        files = await import_node_fs9.promises.readdir(profileDir);
+        files = await import_node_fs10.promises.readdir(profileDir);
       } catch {
         continue;
       }
@@ -10379,7 +11272,7 @@ async function cleanupLegacyCanonicalSources() {
         if (!file.startsWith("profile.json")) {
           continue;
         }
-        await removeIfExists(import_node_path15.default.join(profileDir, file));
+        await removeIfExists(import_node_path16.default.join(profileDir, file));
       }
     }
   } catch (error) {
@@ -10392,12 +11285,12 @@ async function cleanupLegacyCanonicalSources() {
   }
   const skillsRoot = resolveLegacyPath(LEGACY_SKILLS_DIR);
   try {
-    const skillDirs = await import_node_fs9.promises.readdir(skillsRoot, { withFileTypes: true });
+    const skillDirs = await import_node_fs10.promises.readdir(skillsRoot, { withFileTypes: true });
     for (const entry of skillDirs) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) {
         continue;
       }
-      await removeIfExists(import_node_path15.default.join(skillsRoot, entry.name, LEGACY_SKILL_MANIFEST));
+      await removeIfExists(import_node_path16.default.join(skillsRoot, entry.name, LEGACY_SKILL_MANIFEST));
     }
   } catch (error) {
     if (!isMissingPathError(error)) {
@@ -10610,7 +11503,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.9.1" : "0.0.0";
+var VERSION = true ? "3.9.7" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {