codexuse-cli 5.0.2 → 5.0.6

package/dist/index.js

@@ -2054,6 +2054,7 @@ var DEFAULT_AUTO_ROLL_ENABLED = false;
 var DEFAULT_AUTO_ROLL_REARM_REMAINING_THRESHOLD = 15;
 var DEFAULT_AUTO_ROLL_SWITCH_REMAINING_THRESHOLD = 5;
 var DEFAULT_LAUNCH_OFFICIAL_CODEX_WHEN_CLOSED_ON_AUTO_ROLL = false;
+var DEFAULT_HANDOFF_RUNNING_THREADS_ON_ACCOUNT_SWITCH = false;
 var DEFAULT_AUTO_ROLL_PRIORITY_ORDER = [];
 var DEFAULT_LOW_REMAINING_NOTIFICATION_ENABLED = false;
 var DEFAULT_LOW_REMAINING_NOTIFICATION_THRESHOLD = 1;
@@ -2157,6 +2158,7 @@ function normalizeAutoRollSettings(raw) {
     rearmRemainingThreshold: normalizedRearm,
     switchRemainingThreshold: normalizedSwitch,
     launchOfficialCodexWhenClosedOnAutoRoll: raw?.launchOfficialCodexWhenClosedOnAutoRoll === true ? true : DEFAULT_LAUNCH_OFFICIAL_CODEX_WHEN_CLOSED_ON_AUTO_ROLL,
+    handoffRunningThreadsOnAccountSwitch: raw?.handoffRunningThreadsOnAccountSwitch === true ? true : DEFAULT_HANDOFF_RUNNING_THREADS_ON_ACCOUNT_SWITCH,
     priorityOrder: sanitizeAutoRollPriorityOrder(raw?.priorityOrder),
     lowRemainingNotificationEnabled: raw?.lowRemainingNotificationEnabled === true ? true : DEFAULT_LOW_REMAINING_NOTIFICATION_ENABLED,
     lowRemainingNotificationThreshold: sanitizeLowRemainingNotificationThreshold(
@@ -2530,6 +2532,7 @@ function createDefaultAppState() {
       rearmRemainingThreshold: 15,
       switchRemainingThreshold: 5,
       launchOfficialCodexWhenClosedOnAutoRoll: false,
+      handoffRunningThreadsOnAccountSwitch: false,
       priorityOrder: [],
       lowRemainingNotificationEnabled: false,
       lowRemainingNotificationThreshold: 1
@@ -2631,6 +2634,20 @@ function asString(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
 }
+function asStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return value.flatMap((entry) => {
+    const normalized = asString(entry);
+    if (!normalized || seen.has(normalized)) {
+      return [];
+    }
+    seen.add(normalized);
+    return [normalized];
+  });
+}
 function asNumberOrNull(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
@@ -2954,7 +2971,10 @@ function normalizeAppState(raw) {
       sourceProfileKey: asString(debt.sourceProfileKey),
       decisionId: asString(debt.decisionId),
       attempts: asNumberOrNull(debt.attempts) ?? 0,
-      lastReason: asString(debt.lastReason)
+      lastReason: asString(debt.lastReason),
+      handoffReason: debt.handoffReason === "manual" || debt.handoffReason === "auto-roll" ? debt.handoffReason : null,
+      handoffThreadIds: asStringArray(debt.handoffThreadIds),
+      handoffSentThreadIds: asStringArray(debt.handoffSentThreadIds)
     } : null;
   } else {
     merged.officialCodex.pendingActivationDebt = null;
@@ -3496,6 +3516,7 @@ async function writeCodexSettingsJsonRaw(payload) {
       rearmRemainingThreshold: autoRoll.rearmRemainingThreshold,
       switchRemainingThreshold: autoRoll.switchRemainingThreshold,
       launchOfficialCodexWhenClosedOnAutoRoll: autoRoll.launchOfficialCodexWhenClosedOnAutoRoll,
+      handoffRunningThreadsOnAccountSwitch: autoRoll.handoffRunningThreadsOnAccountSwitch,
       priorityOrder: autoRoll.priorityOrder,
       lowRemainingNotificationEnabled: autoRoll.lowRemainingNotificationEnabled,
       lowRemainingNotificationThreshold: autoRoll.lowRemainingNotificationThreshold
@@ -3927,7 +3948,7 @@ var import_node_crypto3 = require("crypto");
 var import_fs = require("fs");
 var import_path = __toESM(require("path"), 1);
 var import_path2 = require("path");
-var import_toml = __toESM(require_toml(), 1);
+var import_toml2 = __toESM(require_toml(), 1);
 
 // ../../packages/contracts/src/profiles/identity.ts
 function normalizeValue(value) {
@@ -3981,6 +4002,7 @@ var import_node_readline = __toESM(require("readline"), 1);
 var import_node_fs3 = require("fs");
 var import_node_os2 = __toESM(require("os"), 1);
 var import_node_path5 = __toESM(require("path"), 1);
+var import_toml = __toESM(require_toml(), 1);
 
 // ../../packages/runtime-codex/src/codex/cli.ts
 var import_node_fs2 = require("fs");
@@ -4206,6 +4228,12 @@ var ACTIVATION_MODEL = "gpt-5.1-codex-mini";
 var MAX_STDERR_CAPTURE_CHARS = 32768;
 var REFRESH_TOKEN_REDEEMED_SNIPPET = "refresh token was already used";
 var authFileCache = /* @__PURE__ */ new Map();
+var CODEX_OAUTH_REFRESH_URL = "https://auth.openai.com/oauth/token";
+var CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var CODEX_OAUTH_REFRESH_MAX_AGE_MS = 8 * 24 * 60 * 60 * 1e3;
+var CODEX_OAUTH_ACCESS_TOKEN_REFRESH_SKEW_MS = 2 * 60 * 1e3;
+var CODEX_USAGE_DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
+var CODEX_USAGE_TIMEOUT_MS = 3e4;
 function isRecord4(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -4429,6 +4457,17 @@ function extractJwtIssuedAtMs(token) {
   }
   return issuedAt * 1e3;
 }
+function extractJwtExpiresAtMs(token) {
+  const payload = decodeJwtPayload(token);
+  if (!payload) {
+    return null;
+  }
+  const expiresAt = payload["exp"];
+  if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt)) {
+    return null;
+  }
+  return expiresAt * 1e3;
+}
 function parseAuthRecord(content) {
   try {
     const parsed = JSON.parse(content);
@@ -4517,6 +4556,353 @@ async function writeAuthFileCached(filePath, content) {
     authFileCache.delete(filePath);
   }
 }
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveCodexAuthPathForEnv(envOverride) {
+  return envOverride?.CODEX_HOME ? import_node_path5.default.join(envOverride.CODEX_HOME, "auth.json") : import_node_path5.default.join(
+    envOverride?.HOME ?? process.env.HOME ?? import_node_os2.default.homedir(),
+    ".codex",
+    "auth.json"
+  );
+}
+function parseCodexOAuthCredentials(content) {
+  const parsed = parseAuthRecord(content);
+  if (!parsed) {
+    return null;
+  }
+  const tokens = isRecord4(parsed.tokens) ? parsed.tokens : {};
+  const accessToken = nonEmptyString(tokens.access_token) ?? nonEmptyString(parsed.access_token);
+  const refreshToken = nonEmptyString(tokens.refresh_token) ?? nonEmptyString(parsed.refresh_token);
+  if (!accessToken && !refreshToken) {
+    return null;
+  }
+  return {
+    accessToken: accessToken ?? "",
+    refreshToken: refreshToken ?? "",
+    idToken: nonEmptyString(tokens.id_token) ?? nonEmptyString(parsed.id_token),
+    accountId: nonEmptyString(tokens.account_id) ?? nonEmptyString(parsed.account_id),
+    lastRefreshMs: parseTimestamp2(tokens.last_refresh) ?? parseTimestamp2(parsed.last_refresh)
+  };
+}
+function shouldRefreshCodexOAuthToken(credentials) {
+  if (!credentials.refreshToken) {
+    return false;
+  }
+  const accessExpiresAt = extractJwtExpiresAtMs(credentials.accessToken);
+  if (accessExpiresAt !== null && accessExpiresAt - Date.now() <= CODEX_OAUTH_ACCESS_TOKEN_REFRESH_SKEW_MS) {
+    return true;
+  }
+  if (credentials.lastRefreshMs === null) {
+    return true;
+  }
+  return Date.now() - credentials.lastRefreshMs > CODEX_OAUTH_REFRESH_MAX_AGE_MS;
+}
+async function writeCodexOAuthCredentials(authPath, content, credentials) {
+  let json = {};
+  try {
+    const parsed = JSON.parse(content);
+    if (isRecord4(parsed)) {
+      json = { ...parsed };
+    }
+  } catch {
+    json = {};
+  }
+  const existingTokens = isRecord4(json.tokens) ? json.tokens : {};
+  json.tokens = {
+    ...existingTokens,
+    access_token: credentials.accessToken,
+    refresh_token: credentials.refreshToken,
+    ...credentials.idToken ? { id_token: credentials.idToken } : {},
+    ...credentials.accountId ? { account_id: credentials.accountId } : {},
+    last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  json.last_refresh = (/* @__PURE__ */ new Date()).toISOString();
+  await writeAuthFileCached(authPath, `${JSON.stringify(json, null, 2)}
+`);
+}
+async function refreshCodexOAuthCredentials(credentials) {
+  if (!credentials.refreshToken) {
+    return credentials;
+  }
+  const response = await fetch(CODEX_OAUTH_REFRESH_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    signal: AbortSignal.timeout(CODEX_USAGE_TIMEOUT_MS),
+    body: JSON.stringify({
+      client_id: CODEX_OAUTH_CLIENT_ID,
+      grant_type: "refresh_token",
+      refresh_token: credentials.refreshToken,
+      scope: "openid profile email"
+    })
+  });
+  const body = await response.text();
+  if (!response.ok) {
+    let code = "";
+    try {
+      const parsed2 = JSON.parse(body);
+      if (isRecord4(parsed2)) {
+        const error = isRecord4(parsed2.error) ? parsed2.error : {};
+        code = nonEmptyString(error.code) ?? nonEmptyString(parsed2.error) ?? nonEmptyString(parsed2.code) ?? "";
+      }
+    } catch {
+      code = "";
+    }
+    if (code === "refresh_token_reused") {
+      throw new Error("refresh token was already used");
+    }
+    if (code === "refresh_token_expired") {
+      throw new Error("refresh token expired");
+    }
+    if (code === "invalid_grant" || code === "refresh_token_invalidated") {
+      throw new Error("refresh token was revoked");
+    }
+    throw new Error(`Codex OAuth refresh failed HTTP ${response.status}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw new Error("Codex OAuth refresh returned invalid JSON");
+  }
+  if (!isRecord4(parsed)) {
+    throw new Error("Codex OAuth refresh returned invalid data");
+  }
+  return {
+    accessToken: nonEmptyString(parsed.access_token) ?? credentials.accessToken,
+    refreshToken: nonEmptyString(parsed.refresh_token) ?? credentials.refreshToken,
+    idToken: nonEmptyString(parsed.id_token) ?? credentials.idToken,
+    accountId: credentials.accountId,
+    lastRefreshMs: Date.now()
+  };
+}
+async function loadCodexConfigContents(envOverride) {
+  const codexHome = envOverride?.CODEX_HOME?.trim();
+  const root = codexHome || import_node_path5.default.join(envOverride?.HOME ?? process.env.HOME ?? import_node_os2.default.homedir(), ".codex");
+  try {
+    return await import_node_fs3.promises.readFile(import_node_path5.default.join(root, "config.toml"), "utf8");
+  } catch {
+    return null;
+  }
+}
+function parseChatGPTBaseUrl(contents) {
+  if (!contents) {
+    return CODEX_USAGE_DEFAULT_BASE_URL;
+  }
+  try {
+    const parsed = (0, import_toml.parse)(contents);
+    if (isRecord4(parsed)) {
+      return nonEmptyString(parsed.chatgpt_base_url) ?? CODEX_USAGE_DEFAULT_BASE_URL;
+    }
+  } catch {
+    return CODEX_USAGE_DEFAULT_BASE_URL;
+  }
+  return CODEX_USAGE_DEFAULT_BASE_URL;
+}
+async function resolveCodexUsageUrl(envOverride) {
+  let base = parseChatGPTBaseUrl(await loadCodexConfigContents(envOverride));
+  while (base.endsWith("/")) {
+    base = base.slice(0, -1);
+  }
+  if ((base.startsWith("https://chatgpt.com") || base.startsWith("https://chat.openai.com")) && !base.includes("/backend-api")) {
+    base += "/backend-api";
+  }
+  return `${base}${base.includes("/backend-api") ? "/wham/usage" : "/api/codex/usage"}`;
+}
+function numberFromUnknown(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function toOAuthWindow(window) {
+  if (!window) {
+    return void 0;
+  }
+  const usedPercent = numberFromUnknown(window.used_percent);
+  const resetAt = numberFromUnknown(window.reset_at);
+  const limitWindowSeconds = numberFromUnknown(window.limit_window_seconds);
+  if (usedPercent === null && resetAt === null && limitWindowSeconds === null) {
+    return void 0;
+  }
+  const result = {};
+  if (usedPercent !== null) {
+    result.usedPercent = Math.max(0, Math.min(100, usedPercent));
+  }
+  if (limitWindowSeconds !== null) {
+    result.windowMinutes = Math.round(limitWindowSeconds / 60);
+  }
+  if (resetAt !== null) {
+    const resetMs = resetAt > 1e10 ? resetAt : resetAt * 1e3;
+    result.resetsAt = new Date(resetMs).toISOString();
+    result.resetsInSeconds = Math.max(0, Math.round((resetMs - Date.now()) / 1e3));
+  }
+  return result;
+}
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    const text = nonEmptyString(value);
+    if (text) {
+      return text;
+    }
+  }
+  return null;
+}
+function slugForRateLimitId(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isSparkRateLimit(limitName, meteredFeature) {
+  return [limitName, meteredFeature].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes("spark"));
+}
+function sparkWindowIdentity(window, fallback) {
+  const limitWindowSeconds = numberFromUnknown(window.limit_window_seconds);
+  const windowMinutes = limitWindowSeconds !== null ? Math.round(limitWindowSeconds / 60) : null;
+  const kind = windowMinutes !== null && windowMinutes > 0 && windowMinutes <= 6 * 60 ? "five-hour" : windowMinutes !== null && windowMinutes >= 6 * 24 * 60 ? "weekly" : fallback;
+  return kind === "weekly" ? { id: "codex-spark-weekly", label: "Codex Spark Weekly" } : { id: "codex-spark", label: "Codex Spark 5-hour" };
+}
+function toExtraRateLimitWindow(args) {
+  const window = toOAuthWindow(args.window);
+  if (!window) {
+    return null;
+  }
+  return {
+    id: args.id,
+    label: args.label,
+    ...args.meteredFeature ? { meteredFeature: args.meteredFeature } : {},
+    ...window
+  };
+}
+function parseExtraRateLimitWindows(additionalRateLimits) {
+  if (!Array.isArray(additionalRateLimits)) {
+    return [];
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  const extraWindows = [];
+  for (const entry of additionalRateLimits) {
+    if (!isRecord4(entry)) {
+      continue;
+    }
+    const limitName = firstNonEmptyString(entry.limit_name);
+    const meteredFeature = firstNonEmptyString(entry.metered_feature);
+    const rateLimit = isRecord4(entry.rate_limit) ? entry.rate_limit : null;
+    if (!rateLimit) {
+      continue;
+    }
+    const primary = isRecord4(rateLimit.primary_window) ? rateLimit.primary_window : null;
+    const secondary = isRecord4(rateLimit.secondary_window) ? rateLimit.secondary_window : null;
+    if (isSparkRateLimit(limitName, meteredFeature)) {
+      const candidates = [
+        { window: primary, fallback: "five-hour" },
+        { window: secondary, fallback: "weekly" }
+      ];
+      for (const candidate of candidates) {
+        if (!candidate.window) {
+          continue;
+        }
+        const identity = sparkWindowIdentity(candidate.window, candidate.fallback);
+        if (usedIds.has(identity.id)) {
+          continue;
+        }
+        const extraWindow2 = toExtraRateLimitWindow({
+          ...identity,
+          meteredFeature,
+          window: candidate.window
+        });
+        if (extraWindow2) {
+          usedIds.add(identity.id);
+          extraWindows.push(extraWindow2);
+        }
+      }
+      continue;
+    }
+    const idSource = firstNonEmptyString(meteredFeature, limitName);
+    const slug = idSource ? slugForRateLimitId(idSource) : "";
+    if (!slug) {
+      continue;
+    }
+    const id = `codex-${slug}`;
+    if (usedIds.has(id)) {
+      continue;
+    }
+    const extraWindow = toExtraRateLimitWindow({
+      id,
+      label: firstNonEmptyString(limitName, meteredFeature) ?? "Codex extra limit",
+      meteredFeature,
+      window: primary ?? secondary
+    });
+    if (extraWindow) {
+      usedIds.add(id);
+      extraWindows.push(extraWindow);
+    }
+  }
+  return extraWindows;
+}
+function parseRateLimitSnapshotFromOAuthUsage(value) {
+  if (!isRecord4(value)) {
+    throw new Error("Codex usage API returned invalid data");
+  }
+  const usage = value;
+  const primary = toOAuthWindow(usage.rate_limit?.primary_window ?? null);
+  const secondary = toOAuthWindow(usage.rate_limit?.secondary_window ?? null);
+  const extraWindows = parseExtraRateLimitWindows(usage.additional_rate_limits);
+  if (!primary && !secondary && extraWindows.length === 0) {
+    return null;
+  }
+  return {
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "codex-oauth",
+    ...primary ? { primary } : {},
+    ...secondary ? { secondary } : {},
+    ...extraWindows.length > 0 ? { extraWindows } : {}
+  };
+}
+async function fetchRateLimitsViaOAuth(envOverride) {
+  const authPath = resolveCodexAuthPathForEnv(envOverride);
+  const authContent = await readAuthFileCached(authPath);
+  if (!authContent) {
+    return null;
+  }
+  let credentials = parseCodexOAuthCredentials(authContent);
+  if (!credentials) {
+    return null;
+  }
+  if (shouldRefreshCodexOAuthToken(credentials)) {
+    credentials = await refreshCodexOAuthCredentials(credentials);
+    await writeCodexOAuthCredentials(authPath, authContent, credentials);
+  }
+  if (!credentials.accessToken) {
+    return null;
+  }
+  const usageUrl = await resolveCodexUsageUrl(envOverride);
+  const response = await fetch(usageUrl, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${credentials.accessToken}`,
+      Accept: "application/json",
+      "User-Agent": "CodexUse",
+      ...credentials.accountId ? { "ChatGPT-Account-Id": credentials.accountId } : {}
+    },
+    signal: AbortSignal.timeout(CODEX_USAGE_TIMEOUT_MS)
+  });
+  const body = await response.text();
+  if (response.status === 401 || response.status === 403) {
+    throw new Error(`Codex OAuth usage failed HTTP ${response.status} (${usageUrl})`);
+  }
+  if (!response.ok) {
+    throw new Error(`Codex usage API failed HTTP ${response.status} (${usageUrl}): ${body.slice(0, 500)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw new Error("Codex usage API returned invalid JSON");
+  }
+  return parseRateLimitSnapshotFromOAuthUsage(parsed);
+}
 function inferRefreshFailureHint(stderrOutput) {
   if (!stderrOutput) {
     return null;
@@ -6129,7 +6515,7 @@ var ProfileManager = class {
     }
     let parsed;
     try {
-      parsed = (0, import_toml.parse)(raw);
+      parsed = (0, import_toml2.parse)(raw);
     } catch (error) {
       logWarn(`Failed to parse config.toml for profile home '${profileHome}':`, error);
       return;
@@ -6139,7 +6525,7 @@ var ProfileManager = class {
     }
     delete parsed["model_reasoning_effort"];
     const sanitized = this.ensureTrailingNewline(
-      (0, import_toml.stringify)(parsed)
+      (0, import_toml2.stringify)(parsed)
     );
     try {
       await import_fs.promises.writeFile(configPath, sanitized, "utf8");
@@ -6503,7 +6889,16 @@ var ProfileManager = class {
         profileName,
         () => this.runWithPreparedProfileHome(
           profileName,
-          (env) => fetchRateLimitsViaRpc(env, { codexPath: options.codexPath }),
+          async (env) => {
+            try {
+              const oauthSnapshot = await fetchRateLimitsViaOAuth(env);
+              if (oauthSnapshot) {
+                return oauthSnapshot;
+              }
+            } catch {
+            }
+            return fetchRateLimitsViaRpc(env, { codexPath: options.codexPath });
+          },
           { syncFromActiveAuthBeforeAction: false }
         )
       );
@@ -7877,7 +8272,8 @@ function maxUsedPercent(snapshot) {
   }
   const candidates = [
     snapshot.primary?.usedPercent,
-    snapshot.secondary?.usedPercent
+    snapshot.secondary?.usedPercent,
+    ...(snapshot.extraWindows ?? []).map((window) => window.usedPercent)
   ].filter((value) => typeof value === "number" && Number.isFinite(value));
   if (candidates.length === 0) {
     return null;
@@ -8006,7 +8402,8 @@ function formatUsagePercent(value) {
 function snapshotResetSeconds(snapshot) {
   const values = [
     snapshot?.primary?.resetsInSeconds,
-    snapshot?.secondary?.resetsInSeconds
+    snapshot?.secondary?.resetsInSeconds,
+    ...(snapshot?.extraWindows ?? []).map((window) => window.resetsInSeconds)
   ].filter((value) => typeof value === "number" && Number.isFinite(value));
   return values.length > 0 ? Math.min(...values) : null;
 }
@@ -12743,9 +13140,12 @@ function isMainProcessRow(row, candidate) {
 }
 function findAppServerPid(rows, mainPid) {
   return rows.find(
-    (row) => row.ppid === mainPid && row.args.includes("/Contents/Resources/codex app-server")
+    (row) => row.ppid === mainPid && isAppServerProcessRow(row)
   )?.pid ?? null;
 }
+function isAppServerProcessRow(row) {
+  return row.args.includes("/Contents/Resources/codex app-server");
+}
 async function processMatchesProfileHome(pid, profileHome) {
   const result = await runCommand2(
     "/bin/ps",
@@ -12759,7 +13159,7 @@ async function processMatchesProfileHome(pid, profileHome) {
 }
 async function findAppServerPidForProfile(rows, mainPid, profileHome) {
   const candidates = rows.filter(
-    (row) => row.ppid === mainPid && row.args.includes("/Contents/Resources/codex app-server")
+    (row) => row.ppid === mainPid && isAppServerProcessRow(row)
   );
   for (const row of candidates) {
     if (row.args.includes(profileHome) || await processMatchesProfileHome(row.pid, profileHome)) {
@@ -12768,6 +13168,19 @@ async function findAppServerPidForProfile(rows, mainPid, profileHome) {
   }
   return null;
 }
+async function resolveStoredAppServerPid(instance, rows) {
+  if (!instance.appServerPid) {
+    return null;
+  }
+  const row = rows.find((entry) => entry.pid === instance.appServerPid);
+  if (!row || !isAppServerProcessRow(row)) {
+    return null;
+  }
+  if (instance.profileHome && !row.args.includes(instance.profileHome) && !await processMatchesProfileHome(row.pid, instance.profileHome)) {
+    return null;
+  }
+  return row.pid;
+}
 function parseRemoteDebuggingPort(args) {
   const match = args.match(/--remote-debugging-port(?:=|\s+)(\d{2,5})\b/);
   const port = Number(match?.[1]);
@@ -12896,11 +13309,27 @@ async function readManagedInstance(profileName) {
 async function resolveInstanceRuntimeState(args) {
   const pid = args.instance.pid;
   if (!pid) {
-    return { running: false, appServerPid: null, startedAt: null };
+    const appServerPid2 = await resolveStoredAppServerPid(
+      args.instance,
+      args.rows
+    );
+    return {
+      running: appServerPid2 !== null,
+      appServerPid: appServerPid2,
+      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 appServerPid2 = await resolveStoredAppServerPid(
+      args.instance,
+      args.rows
+    );
+    return {
+      running: appServerPid2 !== null,
+      appServerPid: appServerPid2,
+      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) {
@@ -13813,8 +14242,8 @@ function formatResetText(window) {
   if (durationText === "now") return "now";
   return `in ${durationText}`;
 }
-function formatWindowUsage(window) {
-  const label = formatWindowLabel(window.windowMinutes) ?? "window";
+function formatWindowUsage(window, labelOverride) {
+  const label = labelOverride ?? formatWindowLabel(window.windowMinutes) ?? "window";
   const usedPercent = typeof window.usedPercent === "number" && Number.isFinite(window.usedPercent) ? `${Math.round(Math.max(0, Math.min(100, window.usedPercent)))}%` : "n/a";
   const resetText = formatResetText(window);
   return {
@@ -13943,6 +14372,10 @@ async function resolveProfileUsage(manager, profile, codexPath) {
       const row = formatWindowUsage(snapshot.secondary);
       if (row) rows.push(row);
     }
+    for (const window of snapshot.extraWindows ?? []) {
+      const row = formatWindowUsage(window, window.label);
+      if (row) rows.push(row);
+    }
     const maxPercent = maxUsedPercent(snapshot);
     const summary = typeof maxPercent === "number" ? `${Math.round(maxPercent)}%` : "n/a";
     return { summary, rows: rows.length > 0 ? rows : null, usageSummary: summarizeRateLimitSnapshot(snapshot) };
@@ -14833,7 +15266,7 @@ async function pushRemoteSnapshot(licenseKey, snapshot, options) {
 }
 
 // ../../packages/runtime-codex/src/codex/config.ts
-var import_toml2 = __toESM(require_toml(), 1);
+var import_toml3 = __toESM(require_toml(), 1);
 
 // ../../packages/runtime-codex/src/codex/config-metadata.ts
 var import_node_child_process6 = require("child_process");
@@ -15472,7 +15905,7 @@ function formatUserFacingError(error, options = {}) {
 // ../../packages/runtime-codex/src/codex/config.ts
 function tryParseToml(content) {
   try {
-    const parsed = (0, import_toml2.parse)(content);
+    const parsed = (0, import_toml3.parse)(content);
     return { data: parsed ?? {}, error: null };
   } catch (error) {
     const maybe = error;
@@ -16157,7 +16590,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "5.0.2" : "0.0.0";
+var VERSION = true ? "5.0.6" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {