codexuse-cli 3.9.2 → 3.9.8

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,25 @@ 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,
+      activity: [],
+      instancesByProfileName: {},
+      pendingRestartDebt: null
     },
     app: {
       lastAppVersion: null,
@@ -2454,34 +2581,114 @@ 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 asBooleanOrNull(value) {
+  return typeof value === "boolean" ? 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;
-  }
-  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;
+  merged.autoRoll = normalizeAutoRollSettings(rawAutoRoll);
+  if (!isRecord2(merged.officialCodex)) {
+    merged.officialCodex = clone2(defaults.officialCodex);
   }
-  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
+  );
+  merged.officialCodex.activity = Array.isArray(merged.officialCodex.activity) ? merged.officialCodex.activity.filter((entry) => isRecord2(entry)).map((entry) => ({
+    id: asString(entry.id) ?? "",
+    at: asString(entry.at) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    kind: entry.kind === "auto-roll-eval" || entry.kind === "profile-switch" || entry.kind === "auth-verified" || entry.kind === "official-codex-restart" || entry.kind === "low-remaining-alert" ? entry.kind : "auto-roll-eval",
+    status: asString(entry.status) ?? "unknown",
+    reason: asString(entry.reason),
+    decisionId: asString(entry.decisionId),
+    profileName: asString(entry.profileName),
+    sourceProfileName: asString(entry.sourceProfileName),
+    targetProfileName: asString(entry.targetProfileName),
+    remainingPercent: asNumberOrNull(entry.remainingPercent),
+    threshold: asNumberOrNull(entry.threshold),
+    snapshotAgeMs: asNumberOrNull(entry.snapshotAgeMs),
+    snapshotSource: asString(entry.snapshotSource),
+    phase: asString(entry.phase),
+    pid: asNumberOrNull(entry.pid),
+    profileKeyHash: asString(entry.profileKeyHash),
+    switchVerified: asBooleanOrNull(entry.switchVerified),
+    restartRequested: asBooleanOrNull(entry.restartRequested),
+    restartResult: asString(entry.restartResult),
+    observedProfileName: asString(entry.observedProfileName),
+    observedProfileKeyHash: asString(entry.observedProfileKeyHash),
+    observedProfileMatchSource: asString(entry.observedProfileMatchSource)
+  })).filter((entry) => entry.id && entry.at).slice(-50) : [];
+  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;
+  }
+  if (isRecord2(merged.officialCodex.pendingRestartDebt)) {
+    const debt = merged.officialCodex.pendingRestartDebt;
+    const targetProfileName = asString(debt.targetProfileName);
+    merged.officialCodex.pendingRestartDebt = targetProfileName ? {
+      targetProfileName,
+      targetProfileKey: asString(debt.targetProfileKey),
+      sourceProfileName: asString(debt.sourceProfileName),
+      sourceProfileKey: asString(debt.sourceProfileKey),
+      decisionId: asString(debt.decisionId),
+      attempts: asNumberOrNull(debt.attempts) ?? 0,
+      lastReason: asString(debt.lastReason)
+    } : null;
+  } else {
+    merged.officialCodex.pendingRestartDebt = null;
   }
   merged.app.lastAppVersion = asString(merged.app.lastAppVersion);
   merged.app.pendingUpdateVersion = asString(merged.app.pendingUpdateVersion);
@@ -2977,59 +3184,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 +3225,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 +3293,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,
@@ -3882,10 +4029,10 @@ function logError(...args) {
   console.error(...args);
 }
 function logInfo(...args) {
-  if (isTestEnv && !isMocked(console.warn)) {
+  if (isTestEnv && !isMocked(console.info)) {
     return;
   }
-  console.warn(...args);
+  console.info(...args);
 }
 
 // ../../packages/runtime-codex/src/codex/rpc.ts
@@ -4245,21 +4392,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 +4511,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,18 +4554,26 @@ 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 +4971,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 +5115,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 +5138,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 +5200,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 +5275,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 +5309,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;
   }
@@ -5169,11 +5446,17 @@ var ProfileManager = class {
     const existingIdentity = this.resolveProfileIdentityFromData(profileName, existing, existingMetadata);
     const nextIdentity = this.resolveProfileIdentityFromData(profileName, normalized, metadata);
     if (existingIdentity && nextIdentity && existingIdentity !== nextIdentity) {
-      logWarn(
+      logInfo(
         `Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different OpenAI identity.`
       );
       return;
     }
+    if (this.normalizeWorkspaceId(existing.workspace_id) !== this.normalizeWorkspaceId(normalized.workspace_id)) {
+      logInfo(
+        `Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different workspace.`
+      );
+      return;
+    }
     if (!this.hasTokenChanges(existing, normalized)) {
       return;
     }
@@ -5371,94 +5654,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 +5776,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 +5838,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 +5882,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 +5950,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 +6031,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 +6186,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 +6218,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 +6239,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,77 +8042,976 @@ async function assertProfileCreationAllowed(profileManager) {
   }
 }
 
-// src/commands/profile.ts
-function formatProfileLabel(name, displayName) {
-  if (displayName && displayName.trim() && displayName !== name) {
-    return `${displayName} (${name})`;
+// ../../packages/runtime-codex/src/codex/officialAppRestart.ts
+var import_node_child_process7 = require("child_process");
+var import_node_crypto6 = require("crypto");
+var import_node_fs8 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path11 = __toESM(require("path"), 1);
+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 OFFICIAL_CODEX_ACTIVITY_LIMIT = 50;
+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;
   }
-  return name;
+  logger(`[official-codex-restart] ${message}`);
 }
-function profileRateLimitKey(profile) {
-  return resolveProfileIdentityKeyFromProfile(profile);
+function hashProfileKey(profileKey) {
+  if (!profileKey) {
+    return null;
+  }
+  return (0, import_node_crypto6.createHash)("sha256").update(profileKey).digest("hex").slice(0, 12);
+}
+async function recordOfficialCodexActivity(input) {
+  const now = /* @__PURE__ */ new Date();
+  const entry = {
+    id: `${now.getTime().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    at: now.toISOString(),
+    kind: input.kind,
+    status: input.status,
+    reason: input.reason ?? null,
+    decisionId: input.decisionId ?? null,
+    profileName: input.profileName ?? null,
+    sourceProfileName: input.sourceProfileName ?? null,
+    targetProfileName: input.targetProfileName ?? null,
+    remainingPercent: input.remainingPercent ?? null,
+    threshold: input.threshold ?? null,
+    snapshotAgeMs: input.snapshotAgeMs ?? null,
+    snapshotSource: input.snapshotSource ?? null,
+    phase: input.phase ?? null,
+    pid: input.pid ?? null,
+    profileKeyHash: input.profileKeyHash ?? hashProfileKey(input.profileKey),
+    switchVerified: input.switchVerified ?? null,
+    restartRequested: input.restartRequested ?? null,
+    restartResult: input.restartResult ?? null,
+    observedProfileName: input.observedProfileName ?? null,
+    observedProfileKeyHash: input.observedProfileKeyHash ?? hashProfileKey(input.observedProfileKey),
+    observedProfileMatchSource: input.observedProfileMatchSource ?? null
+  };
+  try {
+    await updateAppState((state) => ({
+      officialCodex: {
+        activity: [...state.officialCodex.activity, entry].slice(
+          -OFFICIAL_CODEX_ACTIVITY_LIMIT
+        )
+      }
+    }));
+  } catch (error) {
+    logOfficialCodexRestart("warn", "Failed to record official Codex activity.", {
+      kind: entry.kind,
+      status: entry.status,
+      profileKeyHash: entry.profileKeyHash,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
 }
-function toTitleCase(value) {
-  return value.replace(/\w\S*/g, (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+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 });
+    });
+  });
 }
-function formatShortDate(value) {
-  if (!value) return null;
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) return null;
-  if (typeof Intl !== "undefined" && Intl.DateTimeFormat) {
-    return new Intl.DateTimeFormat(void 0, { month: "short", day: "numeric" }).format(date);
-  }
-  return date.toLocaleDateString();
+function enqueueProfileAction(work) {
+  const run = profileActionLock.then(work, work);
+  profileActionLock = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
 }
-function formatRelativeTime(value) {
-  if (!value) return null;
-  const parsed = Date.parse(value);
-  if (Number.isNaN(parsed)) return null;
-  const diffMs = parsed - Date.now();
-  const absMs = Math.abs(diffMs);
-  if (absMs < 6e4) {
-    return null;
-  }
-  const minutes = Math.round(absMs / 6e4);
-  if (minutes < 60) {
-    return diffMs >= 0 ? `in ${minutes}m` : `${minutes}m ago`;
+async function readProcessRows() {
+  const result = await runCommand2(
+    "/bin/ps",
+    ["-axo", "pid=,ppid=,lstart=,args="],
+    2e3
+  );
+  if (result.code !== 0) {
+    return [];
   }
-  const hours = Math.round(minutes / 60);
-  if (hours < 24) {
-    return diffMs >= 0 ? `in ${hours}h` : `${hours}h ago`;
+  return result.stdout.split(/\r?\n/).flatMap((line) => {
+    const match = line.match(
+      /^\s*(\d+)\s+(\d+)\s+([A-Z][a-z]{2}\s+[A-Z][a-z]{2}\s+\d+\s+\d+:\d+:\d+\s+\d{4})\s+(.+)$/
+    );
+    if (!match) {
+      return [];
+    }
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    const parsedStartedAt = Date.parse(match[3] ?? "");
+    const startedAt = Number.isFinite(parsedStartedAt) ? parsedStartedAt : null;
+    const args = match[4] ?? "";
+    if (!Number.isInteger(pid) || !Number.isInteger(ppid) || !args) {
+      return [];
+    }
+    return [{ pid, ppid, startedAt, args }];
+  });
+}
+function getMainExecutablePath(candidate) {
+  return import_node_path11.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
+}
+function isMainProcessRow(row, candidate) {
+  return row.args.includes(getMainExecutablePath(candidate));
+}
+function findAppServerPid(rows, mainPid) {
+  return rows.find(
+    (row) => row.ppid === mainPid && row.args.includes("/Contents/Resources/codex app-server")
+  )?.pid ?? null;
+}
+async function processMatchesProfileHome(pid, profileHome) {
+  const result = await runCommand2(
+    "/bin/ps",
+    ["eww", "-p", String(pid), "-o", "command="],
+    2e3
+  );
+  if (result.code !== 0) {
+    return false;
   }
-  const days = Math.round(hours / 24);
-  return diffMs >= 0 ? `in ${days}d` : `${days}d ago`;
+  return result.stdout.includes(`CODEX_HOME=${profileHome}`) || result.stdout.includes(profileHome);
 }
-function formatOrganizations(organizations) {
-  if (!organizations || !Array.isArray(organizations) || organizations.length === 0) {
-    return null;
+async function findAppServerPidForProfile(rows, mainPid, profileHome) {
+  const candidates = rows.filter(
+    (row) => row.ppid === mainPid && row.args.includes("/Contents/Resources/codex app-server")
+  );
+  for (const row of candidates) {
+    if (row.args.includes(profileHome) || await processMatchesProfileHome(row.pid, profileHome)) {
+      return row.pid;
+    }
   }
-  const parts = organizations.map((org) => {
-    if (!org) return null;
-    const name = org.title || org.id;
-    if (!name) return null;
-    return org.role ? `${name} (${org.role})` : name;
-  }).filter((value) => Boolean(value));
-  return parts.length > 0 ? parts.join(", ") : null;
+  return null;
 }
-function formatWindowLabel(windowMinutes) {
-  if (typeof windowMinutes !== "number" || Number.isNaN(windowMinutes)) {
-    return null;
+async function describeUnmanagedProfileHint(appServerPid) {
+  if (!appServerPid) {
+    return {};
   }
-  if (windowMinutes >= 2880) {
-    const days = windowMinutes / 1440;
-    const rounded = Math.round(days * 10) / 10;
-    const display = Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1);
-    return `${display.replace(/\.0$/, "")}d window`;
+  const result = await runCommand2(
+    "/bin/ps",
+    ["eww", "-p", String(appServerPid), "-o", "command="],
+    2e3
+  );
+  if (result.code !== 0) {
+    return {};
   }
-  if (windowMinutes >= 60) {
-    const hours = windowMinutes / 60;
-    const rounded = Math.round(hours * 10) / 10;
-    const display = Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1);
-    return `${display.replace(/\.0$/, "")}h window`;
+  const telemetryMatch = result.stdout.match(
+    /CODEX_TELEMETRY_LABEL=codexuse-profile-([^\s]+)/
+  );
+  if (telemetryMatch?.[1]) {
+    const encodedProfileName = telemetryMatch[1];
+    let profileName = encodedProfileName;
+    try {
+      profileName = decodeURIComponent(encodedProfileName);
+    } catch {
+      profileName = encodedProfileName;
+    }
+    return {
+      profileName,
+      profileMatchSource: "telemetry-label"
+    };
   }
-  const minutes = Math.round(windowMinutes);
+  const profileHomeMatch = result.stdout.match(/profile-homes\/([^\s]+)/);
+  if (profileHomeMatch?.[1]) {
+    return {
+      profileName: profileHomeMatch[1],
+      profileMatchSource: "profile-home"
+    };
+  }
+  return {};
+}
+function getDescendantPids(rootPid, rows) {
+  const descendants = [];
+  const queue = [rootPid];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    for (const row of rows) {
+      if (row.ppid !== current || seen.has(row.pid)) {
+        continue;
+      }
+      descendants.push(row.pid);
+      queue.push(row.pid);
+    }
+  }
+  return descendants;
+}
+async function waitForNewMainPid(candidate, previousPids) {
+  const deadline = Date.now() + LAUNCH_WAIT_MS;
+  while (Date.now() < deadline) {
+    const rows = await readProcessRows();
+    const pid = rows.find((row) => isMainProcessRow(row, candidate) && !previousPids.has(row.pid))?.pid ?? null;
+    if (pid !== null) {
+      return pid;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return null;
+}
+async function waitForMainPid(candidate, pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const rows = await readProcessRows();
+    if (rows.some((row) => row.pid === pid && isMainProcessRow(row, candidate))) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+async function waitForAppServerPid(mainPid, profileHome) {
+  const deadline = Date.now() + LAUNCH_WAIT_MS;
+  while (Date.now() < deadline) {
+    const pid = await findAppServerPidForProfile(
+      await readProcessRows(),
+      mainPid,
+      profileHome
+    );
+    if (pid !== null) {
+      return pid;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return null;
+}
+async function waitForMainPidExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const rows = await readProcessRows();
+    if (!rows.some((row) => row.pid === pid)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+function managedInstanceToPayload(instance, running, appServerPid = instance.appServerPid, startedAt = null) {
+  const runningStartedAt = startedAt ?? instance.launchedAt;
+  return {
+    profileName: instance.profileName,
+    profileKey: instance.profileKey,
+    appPath: instance.appPath,
+    bundleId: instance.bundleId,
+    pid: running ? instance.pid : null,
+    appServerPid: running ? appServerPid : null,
+    running,
+    startedAt: running ? toIso(runningStartedAt) : null,
+    uptimeMs: running && typeof runningStartedAt === "number" ? Math.max(0, Date.now() - runningStartedAt) : null,
+    launchedAt: toIso(instance.launchedAt),
+    lastVerifiedAt: toIso(instance.lastVerifiedAt),
+    lastStatus: instance.lastStatus,
+    lastError: instance.lastError
+  };
+}
+async function patchManagedInstance(instance) {
+  await patchAppState({
+    officialCodex: {
+      instancesByProfileName: {
+        [instance.profileName]: instance
+      }
+    }
+  });
+}
+async function readManagedInstance(profileName) {
+  const state = await getAppState();
+  return state.officialCodex.instancesByProfileName[profileName] ?? null;
+}
+async function resolveInstanceRuntimeState(args) {
+  const pid = args.instance.pid;
+  if (!pid) {
+    return { running: false, appServerPid: null, startedAt: null };
+  }
+  const mainRow = args.rows.find((row) => row.pid === pid);
+  if (!mainRow || !isMainProcessRow(mainRow, args.candidate)) {
+    return { running: false, appServerPid: null, startedAt: null };
+  }
+  const appServerPid = args.instance.profileHome ? await findAppServerPidForProfile(args.rows, pid, args.instance.profileHome) : findAppServerPid(args.rows, pid);
+  if (args.instance.profileHome && appServerPid === null) {
+    return { running: false, appServerPid: null, startedAt: null };
+  }
+  return {
+    running: true,
+    appServerPid,
+    startedAt: mainRow.startedAt
+  };
+}
+async function openCodexWithProfileHome(candidate, profileHome, profileName, previousPids) {
+  const executablePath = getMainExecutablePath(candidate);
+  if (!(0, import_node_fs8.existsSync)(executablePath)) {
+    return { opened: false, pid: null };
+  }
+  const telemetryLabel = `codexuse-profile-${encodeURIComponent(profileName)}`;
+  let child;
+  try {
+    child = (0, import_node_child_process7.spawn)(executablePath, [], {
+      detached: true,
+      env: {
+        ...process.env,
+        CODEX_HOME: profileHome,
+        CODEX_TELEMETRY_LABEL: telemetryLabel
+      },
+      stdio: "ignore"
+    });
+  } catch {
+    return { opened: false, pid: null };
+  }
+  const childPid = child.pid ?? null;
+  child.unref();
+  const spawnError = await new Promise((resolve) => {
+    let settled = false;
+    const settle = (failed) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(failed);
+    };
+    child.once("error", () => settle(true));
+    setTimeout(() => settle(false), POLL_INTERVAL_MS);
+  });
+  if (spawnError) {
+    return { opened: false, pid: null };
+  }
+  if (childPid !== null) {
+    const verified = await waitForMainPid(candidate, childPid, 2e3);
+    if (verified) {
+      return { opened: true, pid: childPid };
+    }
+  }
+  return {
+    opened: true,
+    pid: await waitForNewMainPid(candidate, previousPids)
+  };
+}
+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 signalPids(pids, signal) {
+  const signaled = [];
+  for (const pid of pids) {
+    try {
+      process.kill(pid, signal);
+      signaled.push(pid);
+    } catch {
+    }
+  }
+  return signaled;
+}
+function toIso(value) {
+  return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : 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
+    }
+  });
+}
+function recordOfficialCodexRestartResult(args) {
+  return rememberRestartResult(args);
+}
+function recordOfficialCodexProfileSwitch(profileKey) {
+  return rememberProfileSwitch(profileKey);
+}
+async function getOfficialCodexProfileInstances() {
+  if (process.platform !== "darwin") {
+    return {
+      state: "unsupported",
+      appPath: null,
+      bundleId: null,
+      version: null,
+      instances: [],
+      unmanaged: []
+    };
+  }
+  const { candidate, mainPids } = await resolveCodexAppTarget();
+  if (!candidate) {
+    return {
+      state: "not-found",
+      appPath: null,
+      bundleId: null,
+      version: null,
+      instances: [],
+      unmanaged: []
+    };
+  }
+  const [state, rows] = await Promise.all([getAppState(), readProcessRows()]);
+  const managed = [];
+  for (const instance of Object.values(state.officialCodex.instancesByProfileName)) {
+    const runtime = await resolveInstanceRuntimeState({ instance, candidate, rows });
+    managed.push(
+      managedInstanceToPayload(
+        instance,
+        runtime.running,
+        runtime.appServerPid,
+        runtime.startedAt
+      )
+    );
+  }
+  managed.sort((a, b) => a.profileName.localeCompare(b.profileName));
+  const managedPids = new Set(
+    managed.flatMap((entry) => entry.running && entry.pid ? [entry.pid] : [])
+  );
+  const unmanaged = [];
+  for (const pid of mainPids.filter((entry) => !managedPids.has(entry))) {
+    const appServerPid = findAppServerPid(rows, pid);
+    const startedAt = rows.find((row) => row.pid === pid)?.startedAt ?? null;
+    unmanaged.push({
+      pid,
+      appServerPid,
+      startedAt: toIso(startedAt),
+      uptimeMs: typeof startedAt === "number" ? Math.max(0, Date.now() - startedAt) : null,
+      ...await describeUnmanagedProfileHint(appServerPid)
+    });
+  }
+  return {
+    state: "found",
+    appPath: candidate.appPath,
+    bundleId: candidate.bundleId,
+    version: candidate.version,
+    instances: managed,
+    unmanaged
+  };
+}
+function launchOfficialCodexProfileInstance(options) {
+  return enqueueProfileAction(async () => {
+    if (process.platform !== "darwin") {
+      return {
+        status: "skipped",
+        profileName: options.profileName,
+        instance: null,
+        reason: "unsupported-platform"
+      };
+    }
+    const { candidate, mainPids } = await resolveCodexAppTarget();
+    if (!candidate) {
+      return {
+        status: "skipped",
+        profileName: options.profileName,
+        instance: null,
+        reason: "official-codex-app-not-found"
+      };
+    }
+    const existing = await readManagedInstance(options.profileName);
+    if (existing) {
+      const rows = await readProcessRows();
+      const runtime = await resolveInstanceRuntimeState({ instance: existing, candidate, rows });
+      if (runtime.running) {
+        const verified = {
+          ...existing,
+          profileHome: existing.profileHome ?? options.profileHome,
+          appServerPid: runtime.appServerPid,
+          lastVerifiedAt: Date.now(),
+          lastStatus: "already-running",
+          lastError: null
+        };
+        await patchManagedInstance(verified);
+        return {
+          status: "already-running",
+          profileName: options.profileName,
+          instance: managedInstanceToPayload(
+            verified,
+            true,
+            runtime.appServerPid,
+            runtime.startedAt
+          ),
+          reason: null
+        };
+      }
+    }
+    const launch = await openCodexWithProfileHome(
+      candidate,
+      options.profileHome,
+      options.profileName,
+      new Set(mainPids)
+    );
+    if (!launch.opened) {
+      const failed = {
+        profileName: options.profileName,
+        profileKey: options.profileKey,
+        profileHome: options.profileHome,
+        appPath: candidate.appPath,
+        bundleId: candidate.bundleId,
+        pid: null,
+        appServerPid: null,
+        launchedAt: null,
+        lastVerifiedAt: null,
+        lastStatus: "failed",
+        lastError: "open-failed"
+      };
+      await patchManagedInstance(failed);
+      return {
+        status: "failed",
+        profileName: options.profileName,
+        instance: managedInstanceToPayload(failed, false),
+        reason: "open-failed"
+      };
+    }
+    const launchedPid = launch.pid;
+    if (launchedPid === null) {
+      const failed = {
+        profileName: options.profileName,
+        profileKey: options.profileKey,
+        profileHome: options.profileHome,
+        appPath: candidate.appPath,
+        bundleId: candidate.bundleId,
+        pid: null,
+        appServerPid: null,
+        launchedAt: null,
+        lastVerifiedAt: null,
+        lastStatus: "failed",
+        lastError: "launch-timeout"
+      };
+      await patchManagedInstance(failed);
+      return {
+        status: "failed",
+        profileName: options.profileName,
+        instance: managedInstanceToPayload(failed, false),
+        reason: "launch-timeout"
+      };
+    }
+    const appServerPid = await waitForAppServerPid(
+      launchedPid,
+      options.profileHome
+    );
+    if (appServerPid === null) {
+      const failed = {
+        profileName: options.profileName,
+        profileKey: options.profileKey,
+        profileHome: options.profileHome,
+        appPath: candidate.appPath,
+        bundleId: candidate.bundleId,
+        pid: null,
+        appServerPid: null,
+        launchedAt: null,
+        lastVerifiedAt: Date.now(),
+        lastStatus: "failed",
+        lastError: "app-server-not-verified"
+      };
+      await patchManagedInstance(failed);
+      return {
+        status: "failed",
+        profileName: options.profileName,
+        instance: managedInstanceToPayload(failed, false),
+        reason: "app-server-not-verified"
+      };
+    }
+    const now = Date.now();
+    const instance = {
+      profileName: options.profileName,
+      profileKey: options.profileKey,
+      profileHome: options.profileHome,
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      pid: launchedPid,
+      appServerPid,
+      launchedAt: now,
+      lastVerifiedAt: now,
+      lastStatus: "started",
+      lastError: null
+    };
+    await patchManagedInstance(instance);
+    return {
+      status: "started",
+      profileName: options.profileName,
+      instance: managedInstanceToPayload(instance, true, appServerPid),
+      reason: null
+    };
+  });
+}
+function stopOfficialCodexProfileInstance(profileName) {
+  return enqueueProfileAction(async () => {
+    const existing = await readManagedInstance(profileName);
+    if (!existing) {
+      return {
+        status: "not-running",
+        profileName,
+        instance: null,
+        reason: "not-managed"
+      };
+    }
+    const { candidate } = await resolveCodexAppTarget();
+    if (!candidate) {
+      const stopped2 = {
+        ...existing,
+        pid: null,
+        appServerPid: null,
+        lastVerifiedAt: Date.now(),
+        lastStatus: "not-running",
+        lastError: "official-codex-app-not-found"
+      };
+      await patchManagedInstance(stopped2);
+      return {
+        status: "not-running",
+        profileName,
+        instance: managedInstanceToPayload(stopped2, false),
+        reason: "official-codex-app-not-found"
+      };
+    }
+    const rows = await readProcessRows();
+    const runtime = await resolveInstanceRuntimeState({ instance: existing, candidate, rows });
+    if (!runtime.running || !existing.pid) {
+      const stopped2 = {
+        ...existing,
+        pid: null,
+        appServerPid: null,
+        lastVerifiedAt: Date.now(),
+        lastStatus: "not-running",
+        lastError: null
+      };
+      await patchManagedInstance(stopped2);
+      return {
+        status: "not-running",
+        profileName,
+        instance: managedInstanceToPayload(stopped2, false),
+        reason: null
+      };
+    }
+    const tree = [existing.pid, ...getDescendantPids(existing.pid, rows)].filter((pid, index, all) => all.indexOf(pid) === index).sort((a, b) => b - a);
+    await signalPids(tree, "SIGTERM");
+    const exited = await waitForMainPidExit(existing.pid, 5e3);
+    if (!exited) {
+      await signalPids(tree, "SIGKILL");
+      await waitForMainPidExit(existing.pid, EXIT_WAIT_MS);
+    }
+    const stillRunning = (await readProcessRows()).some((row) => row.pid === existing.pid);
+    const stopped = {
+      ...existing,
+      pid: stillRunning ? existing.pid : null,
+      appServerPid: stillRunning ? runtime.appServerPid : null,
+      lastVerifiedAt: Date.now(),
+      lastStatus: stillRunning ? "failed" : "stopped",
+      lastError: stillRunning ? "stop-timeout" : null
+    };
+    await patchManagedInstance(stopped);
+    return {
+      status: stillRunning ? "failed" : "stopped",
+      profileName,
+      instance: managedInstanceToPayload(
+        stopped,
+        stillRunning,
+        stopped.appServerPid,
+        runtime.startedAt
+      ),
+      reason: stillRunning ? "stop-timeout" : null
+    };
+  });
+}
+function stopOfficialCodexObservedProfileInstance(profileName, pid, appServerPid) {
+  return enqueueProfileAction(async () => {
+    const { candidate } = await resolveCodexAppTarget();
+    if (!candidate) {
+      return {
+        status: "not-running",
+        profileName,
+        instance: null,
+        reason: "official-codex-app-not-found"
+      };
+    }
+    const rows = await readProcessRows();
+    const mainRow = rows.find((row) => row.pid === pid);
+    if (!mainRow || !isMainProcessRow(mainRow, candidate)) {
+      return {
+        status: "not-running",
+        profileName,
+        instance: null,
+        reason: null
+      };
+    }
+    const runtimeAppServerPid = findAppServerPid(rows, pid) ?? appServerPid;
+    const tree = [pid, ...getDescendantPids(pid, rows)].filter((entry, index, all) => all.indexOf(entry) === index).sort((a, b) => b - a);
+    await signalPids(tree, "SIGTERM");
+    const exited = await waitForMainPidExit(pid, 5e3);
+    if (!exited) {
+      await signalPids(tree, "SIGKILL");
+      await waitForMainPidExit(pid, EXIT_WAIT_MS);
+    }
+    const stillRunning = (await readProcessRows()).some((row) => row.pid === pid);
+    const instance = {
+      profileName,
+      profileKey: null,
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      pid: stillRunning ? pid : null,
+      appServerPid: stillRunning ? runtimeAppServerPid : null,
+      running: stillRunning,
+      startedAt: stillRunning ? toIso(mainRow.startedAt) : null,
+      uptimeMs: stillRunning && typeof mainRow.startedAt === "number" ? Math.max(0, Date.now() - mainRow.startedAt) : null,
+      launchedAt: null,
+      lastVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastStatus: stillRunning ? "failed" : "stopped",
+      lastError: stillRunning ? "stop-timeout" : null
+    };
+    return {
+      status: stillRunning ? "failed" : "stopped",
+      profileName,
+      instance,
+      reason: stillRunning ? "stop-timeout" : null
+    };
+  });
+}
+async function restartOfficialCodexProfileInstance(options) {
+  const stopped = await stopOfficialCodexProfileInstance(options.profileName);
+  if (stopped.status === "failed") {
+    return stopped;
+  }
+  const launched = await launchOfficialCodexProfileInstance(options);
+  return {
+    ...launched,
+    status: launched.status === "started" ? "restarted" : launched.status
+  };
+}
+
+// src/commands/profile.ts
+function formatProfileLabel(name, displayName) {
+  if (displayName && displayName.trim() && displayName !== name) {
+    return `${displayName} (${name})`;
+  }
+  return name;
+}
+function profileRateLimitKey(profile) {
+  return resolveProfileIdentityKeyFromProfile(profile);
+}
+function toTitleCase(value) {
+  return value.replace(/\w\S*/g, (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+}
+function formatShortDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  if (typeof Intl !== "undefined" && Intl.DateTimeFormat) {
+    return new Intl.DateTimeFormat(void 0, { month: "short", day: "numeric" }).format(date);
+  }
+  return date.toLocaleDateString();
+}
+function formatRelativeTime(value) {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return null;
+  const diffMs = parsed - Date.now();
+  const absMs = Math.abs(diffMs);
+  if (absMs < 6e4) {
+    return null;
+  }
+  const minutes = Math.round(absMs / 6e4);
+  if (minutes < 60) {
+    return diffMs >= 0 ? `in ${minutes}m` : `${minutes}m ago`;
+  }
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) {
+    return diffMs >= 0 ? `in ${hours}h` : `${hours}h ago`;
+  }
+  const days = Math.round(hours / 24);
+  return diffMs >= 0 ? `in ${days}d` : `${days}d ago`;
+}
+function formatOrganizations(organizations) {
+  if (!organizations || !Array.isArray(organizations) || organizations.length === 0) {
+    return null;
+  }
+  const parts = organizations.map((org) => {
+    if (!org) return null;
+    const name = org.title || org.id;
+    if (!name) return null;
+    return org.role ? `${name} (${org.role})` : name;
+  }).filter((value) => Boolean(value));
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+function formatWindowLabel(windowMinutes) {
+  if (typeof windowMinutes !== "number" || Number.isNaN(windowMinutes)) {
+    return null;
+  }
+  if (windowMinutes >= 2880) {
+    const days = windowMinutes / 1440;
+    const rounded = Math.round(days * 10) / 10;
+    const display = Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1);
+    return `${display.replace(/\.0$/, "")}d window`;
+  }
+  if (windowMinutes >= 60) {
+    const hours = windowMinutes / 60;
+    const rounded = Math.round(hours * 10) / 10;
+    const display = Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1);
+    return `${display.replace(/\.0$/, "")}h window`;
+  }
+  const minutes = Math.round(windowMinutes);
   return `${minutes}m window`;
 }
 function formatDurationFromSeconds(seconds) {
@@ -7812,6 +9059,7 @@ function formatWindowUsage(window) {
 var EMPTY_USAGE_SUMMARY = {
   windowKey: "primary",
   usagePercent: 0,
+  remainingPercent: 100,
   hasUsage: false,
   resetsInSeconds: null,
   windowMinutes: null
@@ -7835,6 +9083,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 +9092,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7853,6 +9103,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7864,6 +9115,7 @@ function summarizeRateLimitSnapshot(snapshot) {
         summary = {
           windowKey: entry.key,
           usagePercent: usageValue,
+          remainingPercent: remainingValue,
           hasUsage,
           resetsInSeconds,
           windowMinutes
@@ -7875,6 +9127,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7885,6 +9138,7 @@ function summarizeRateLimitSnapshot(snapshot) {
       summary = {
         windowKey: entry.key,
         usagePercent: usageValue,
+        remainingPercent: remainingValue,
         hasUsage,
         resetsInSeconds,
         windowMinutes
@@ -7929,9 +9183,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 +9201,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 +9316,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 +9352,231 @@ 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 formatOfficialCodexProfileAction(result) {
+  if (result.status === "restarted") {
+    return "Official Codex restarted.";
+  }
+  if (result.status === "started") {
+    return "Official Codex started.";
+  }
+  if (result.status === "already-running") {
+    return "Official Codex already running.";
+  }
+  if (result.status === "failed") {
+    return `Official Codex restart failed: ${result.reason}.`;
+  }
+  if (result.status === "skipped" || result.status === "not-running") {
+    return `Official Codex restart skipped: ${result.reason}.`;
+  }
+  return "Official Codex restart status unknown.";
+}
+function findUnmanagedOfficialCodexRestartTarget(instances, profileName, profileKey) {
+  const restartable = instances.unmanaged.filter((instance) => instance.pid);
+  const matched = restartable.find((instance) => {
+    if (profileKey && instance.profileKey) {
+      return instance.profileKey === profileKey;
+    }
+    if (instance.profileKey) {
+      return false;
+    }
+    return instance.profileName === profileName;
+  }) ?? null;
+  if (matched) {
+    return { target: matched, ambiguous: false, unverified: false };
+  }
+  if (restartable.length > 1) {
+    return { target: null, ambiguous: true, unverified: false };
+  }
+  return { target: null, ambiguous: false, unverified: restartable.length === 1 };
+}
+async function restartUnmanagedOfficialCodexWindow(profileName, launchOptions, target) {
+  const stopped = await stopOfficialCodexObservedProfileInstance(
+    target.profileName ?? profileName,
+    target.pid,
+    target.appServerPid
+  );
+  if (stopped.status === "failed") {
+    return stopped;
+  }
+  const launched = await launchOfficialCodexProfileInstance(launchOptions);
+  return {
+    ...launched,
+    status: stopped.status === "stopped" && launched.status === "started" ? "restarted" : launched.status
+  };
+}
+async function recordCliOfficialCodexRestartResult(profileName, profileKey, action) {
+  const pid = action.status === "started" || action.status === "restarted" ? action.instance?.pid ?? null : null;
+  const status = action.status === "started" || action.status === "restarted" ? action.status : action.status === "failed" ? "failed" : "skipped";
+  const reason = action.status === "started" || action.status === "restarted" ? null : action.reason ?? action.status;
+  try {
+    await recordOfficialCodexRestartResult({
+      status,
+      reason,
+      profileKey,
+      pid
+    });
+    await recordOfficialCodexActivity({
+      kind: "official-codex-restart",
+      status,
+      reason,
+      targetProfileName: profileName,
+      profileKey,
+      phase: "cli",
+      pid,
+      restartRequested: true,
+      restartResult: status
+    });
+  } catch (error) {
+    console.warn(
+      `Could not record official Codex restart state: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function recordCliOfficialCodexRestartSkipped(profileName, profileKey, reason) {
+  await recordCliOfficialCodexRestartResult(profileName, profileKey, {
+    status: "skipped",
+    profileName,
+    instance: null,
+    reason
+  });
+}
+async function maybeRestartOfficialCodex(options) {
+  if (!options.enabled) {
+    return null;
+  }
+  try {
+    const runtime = await options.manager.prepareProfileRuntime(options.profileName);
+    const launchOptions = {
+      profileName: options.profileName,
+      profileKey: options.profileKey,
+      profileHome: runtime.profileHome
+    };
+    const instances = await getOfficialCodexProfileInstances();
+    if (instances.state === "unsupported") {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "unsupported-platform"
+      );
+      return "Official Codex restart skipped: unsupported-platform.";
+    }
+    if (instances.state === "not-found") {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "official-codex-app-not-found"
+      );
+      return "Official Codex restart skipped: official-codex-app-not-found.";
+    }
+    const managedRunning = instances.instances.some(
+      (instance) => instance.profileName === options.profileName && instance.running
+    );
+    const unmanaged = findUnmanagedOfficialCodexRestartTarget(
+      instances,
+      options.profileName,
+      options.profileKey
+    );
+    if (unmanaged.target && !managedRunning) {
+      const action2 = await restartUnmanagedOfficialCodexWindow(
+        options.profileName,
+        launchOptions,
+        unmanaged.target
+      );
+      await recordCliOfficialCodexRestartResult(
+        options.profileName,
+        options.profileKey,
+        action2
+      );
+      return formatOfficialCodexProfileAction(action2);
+    }
+    if (unmanaged.ambiguous && !managedRunning) {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "ambiguous-official-codex-windows"
+      );
+      return "Official Codex restart skipped: ambiguous-official-codex-windows.";
+    }
+    if (unmanaged.unverified && !managedRunning) {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "unverified-official-codex-window"
+      );
+      return "Official Codex restart skipped: unverified-official-codex-window.";
+    }
+    if (options.launchIfNotRunning === false) {
+      if (!managedRunning) {
+        await recordCliOfficialCodexRestartSkipped(
+          options.profileName,
+          options.profileKey,
+          "official-codex-app-not-running"
+        );
+        return "Official Codex restart skipped: official-codex-app-not-running.";
+      }
+      const action2 = await restartOfficialCodexProfileInstance(launchOptions);
+      await recordCliOfficialCodexRestartResult(
+        options.profileName,
+        options.profileKey,
+        action2
+      );
+      return formatOfficialCodexProfileAction(action2);
+    }
+    const action = await restartOfficialCodexProfileInstance(launchOptions);
+    await recordCliOfficialCodexRestartResult(
+      options.profileName,
+      options.profileKey,
+      action
+    );
+    return formatOfficialCodexProfileAction(action);
+  } catch (error) {
+    await recordCliOfficialCodexRestartResult(options.profileName, options.profileKey, {
+      status: "failed",
+      profileName: options.profileName,
+      instance: null,
+      reason: error instanceof Error ? error.message : "restart-threw"
+    });
+    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 +9626,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 +9649,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 +9683,42 @@ 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({
+    manager,
+    enabled: options.restartOfficialCodex,
+    profileName: candidate.profile.name,
+    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 +9818,52 @@ 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({
+        manager,
+        enabled: restartOfficialCodex,
+        profileName: name,
+        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 +9872,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 +9897,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 +9934,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 +10095,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 +10205,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 +10242,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 +10283,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 +10389,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 +10418,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 +10436,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 +10494,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 +11151,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 +11165,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 +11173,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 +11448,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 +11489,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 +11517,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 +11536,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 +11553,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 +11573,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 +11584,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 +11593,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 +11611,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 +11719,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 +11745,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 +11758,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 +11770,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 +11806,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 +11824,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 +11920,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 +11939,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 +11953,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 +11969,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 +11982,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 +12200,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.9.2" : "0.0.0";
+var VERSION = true ? "3.9.8" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {