codexuse-cli 3.9.8 → 4.0.0

package/dist/index.js

@@ -2216,6 +2216,17 @@ var SQLITE_BUSY_MAX_ATTEMPTS = 3;
 var SQLITE_BUSY_RETRY_DELAY_MS = 100;
 var writeQueueByDbPath = /* @__PURE__ */ new Map();
 var initializedDbPaths = /* @__PURE__ */ new Set();
+var AppStorageCorruptionError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "AppStorageCorruptionError";
+    this.dbPath = options.dbPath;
+    this.namespace = options.namespace ?? null;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -2232,6 +2243,23 @@ function safeParseJson(raw) {
     return null;
   }
 }
+function parseJsonStrict(raw, options) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new AppStorageCorruptionError(
+      `App storage document ${options.namespace} contains invalid JSON.`,
+      {
+        dbPath: options.dbPath,
+        namespace: options.namespace,
+        cause: error
+      }
+    );
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -2240,9 +2268,32 @@ function isSqliteBusyError(error) {
     return false;
   }
   const sqliteError = error;
-  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : "";
+  if (sqliteError.cause && sqliteError.cause !== error && isSqliteBusyError(sqliteError.cause)) {
+    return true;
+  }
+  if (sqliteError.error && sqliteError.error !== error && isSqliteBusyError(sqliteError.error)) {
+    return true;
+  }
+  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : String(error).toLowerCase();
   return sqliteError.code === "SQLITE_BUSY" || sqliteError.errno === 5 || message.includes("sqlite_busy") || message.includes("database is locked");
 }
+function isSqliteCorruptionError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const sqliteError = error;
+  if (sqliteError.cause && sqliteError.cause !== error && isSqliteCorruptionError(sqliteError.cause)) {
+    return true;
+  }
+  if (sqliteError.error && sqliteError.error !== error && isSqliteCorruptionError(sqliteError.error)) {
+    return true;
+  }
+  const message = typeof sqliteError.message === "string" ? sqliteError.message.toLowerCase() : "";
+  return sqliteError.code === "SQLITE_CORRUPT" || sqliteError.code === "SQLITE_NOTADB" || sqliteError.errno === 11 || sqliteError.errno === 26 || message.includes("database disk image is malformed") || message.includes("file is not a database") || message.includes("database corruption") || message.includes("sqlite_corrupt") || message.includes("sqlite_notadb");
+}
+function isAppStorageCorruptionError(error) {
+  return error instanceof AppStorageCorruptionError || isSqliteCorruptionError(error);
+}
 function beginImmediate(db) {
   db.exec("BEGIN IMMEDIATE");
 }
@@ -2317,19 +2368,55 @@ async function openDatabase(dbPath) {
     close: database.close.bind(database)
   };
 }
+function resetAppStorageInitialization(dbPath) {
+  initializedDbPaths.delete(dbPath);
+}
+async function backupCorruptAppStorageDb(dbPath) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${dbPath}.corrupt-${stamp}`;
+  let moved = false;
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const source = `${dbPath}${suffix}`;
+    const destination = `${backupPath}${suffix}`;
+    try {
+      const stats = await import_node_fs.promises.stat(source);
+      if (!stats.isFile()) {
+        continue;
+      }
+      await import_node_fs.promises.rename(source, destination);
+      moved = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  resetAppStorageInitialization(dbPath);
+  return moved ? backupPath : null;
+}
 async function withDatabase(dbPath, task) {
   for (let attempt = 1; attempt <= SQLITE_BUSY_MAX_ATTEMPTS; attempt += 1) {
-    const db = await openDatabase(dbPath);
+    let db = null;
     try {
+      db = await openDatabase(dbPath);
       applyConnectionPragmas(db);
       ensureSchema(db, dbPath);
       return task(db);
     } catch (error) {
+      if (error instanceof AppStorageCorruptionError) {
+        throw error;
+      }
+      if (isSqliteCorruptionError(error)) {
+        throw new AppStorageCorruptionError(
+          "App storage database is corrupt.",
+          { dbPath, cause: error }
+        );
+      }
       if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_MAX_ATTEMPTS) {
         throw error;
       }
     } finally {
-      db.close();
+      db?.close();
     }
     await sleep(SQLITE_BUSY_RETRY_DELAY_MS * attempt);
   }
@@ -2352,6 +2439,40 @@ async function readDocument(dbPath, namespace, normalize) {
     return normalize(parsed);
   });
 }
+async function readDocumentStrict(dbPath, namespace, normalize) {
+  return withDatabase(dbPath, (db) => {
+    const row = useStatement(
+      db,
+      `SELECT value_json AS valueJson FROM ${APP_STORAGE_TABLE} WHERE namespace = ?`,
+      (statement) => statement.get(namespace)
+    );
+    if (!isRecord(row)) {
+      return null;
+    }
+    const parsed = parseJsonStrict(row.valueJson, {
+      dbPath,
+      namespace
+    });
+    if (parsed === null) {
+      throw new AppStorageCorruptionError(
+        `App storage document ${namespace} is empty.`,
+        { dbPath, namespace }
+      );
+    }
+    try {
+      return normalize(parsed);
+    } catch (error) {
+      throw new AppStorageCorruptionError(
+        `App storage document ${namespace} failed normalization.`,
+        {
+          dbPath,
+          namespace,
+          cause: error
+        }
+      );
+    }
+  });
+}
 async function writeDocument(dbPath, namespace, value) {
   return withWriteQueue(
     dbPath,
@@ -2624,7 +2745,7 @@ function normalizeAppState(raw) {
   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",
+    kind: entry.kind === "auto-roll-eval" || entry.kind === "profile-switch" || entry.kind === "auth-verified" || entry.kind === "official-codex-restart" || entry.kind === "reset-window-activation" || entry.kind === "low-remaining-alert" ? entry.kind : "auto-roll-eval",
     status: asString(entry.status) ?? "unknown",
     reason: asString(entry.reason),
     decisionId: asString(entry.decisionId),
@@ -2643,7 +2764,9 @@ function normalizeAppState(raw) {
     restartResult: asString(entry.restartResult),
     observedProfileName: asString(entry.observedProfileName),
     observedProfileKeyHash: asString(entry.observedProfileKeyHash),
-    observedProfileMatchSource: asString(entry.observedProfileMatchSource)
+    observedProfileMatchSource: asString(
+      entry.observedProfileMatchSource
+    )
   })).filter((entry) => entry.id && entry.at).slice(-50) : [];
   if (!isRecord2(merged.officialCodex.instancesByProfileName)) {
     merged.officialCodex.instancesByProfileName = {};
@@ -2767,7 +2890,9 @@ function normalizeAppState(raw) {
   merged.ui.profiles.groupBy = asString(merged.ui.profiles.groupBy);
   merged.ui.profiles.planFilter = asString(merged.ui.profiles.planFilter);
   merged.ui.profiles.healthFilter = asString(merged.ui.profiles.healthFilter);
-  merged.ui.profiles.customGroupFilter = asString(merged.ui.profiles.customGroupFilter);
+  merged.ui.profiles.customGroupFilter = asString(
+    merged.ui.profiles.customGroupFilter
+  );
   if (typeof merged.ui.profiles.toolbarOpen !== "boolean") {
     merged.ui.profiles.toolbarOpen = null;
   }
@@ -2775,13 +2900,15 @@ function normalizeAppState(raw) {
     merged.ui.profiles.collapsedSections = {};
   } else {
     merged.ui.profiles.collapsedSections = Object.fromEntries(
-      Object.entries(merged.ui.profiles.collapsedSections).flatMap(([key, value]) => {
-        const normalizedKey = asString(key);
-        if (!normalizedKey || typeof value !== "boolean") {
-          return [];
+      Object.entries(merged.ui.profiles.collapsedSections).flatMap(
+        ([key, value]) => {
+          const normalizedKey = asString(key);
+          if (!normalizedKey || typeof value !== "boolean") {
+            return [];
+          }
+          return [[normalizedKey, value]];
         }
-        return [[normalizedKey, value]];
-      })
+      )
     );
   }
   if (!isRecord2(merged.ui.onboarding)) {
@@ -2810,26 +2937,30 @@ function normalizeAppState(raw) {
     merged.ui.onboarding.nudgeCooldowns = {};
   } else {
     merged.ui.onboarding.nudgeCooldowns = Object.fromEntries(
-      Object.entries(merged.ui.onboarding.nudgeCooldowns).flatMap(([key, value]) => {
-        const normalizedKey = asString(key);
-        if (!normalizedKey || !Number.isFinite(value)) {
-          return [];
+      Object.entries(merged.ui.onboarding.nudgeCooldowns).flatMap(
+        ([key, value]) => {
+          const normalizedKey = asString(key);
+          if (!normalizedKey || !Number.isFinite(value)) {
+            return [];
+          }
+          return [[normalizedKey, Number(value)]];
         }
-        return [[normalizedKey, Number(value)]];
-      })
+      )
     );
   }
   if (!isRecord2(merged.ui.onboarding.nudgeDismissCount)) {
     merged.ui.onboarding.nudgeDismissCount = {};
   } else {
     merged.ui.onboarding.nudgeDismissCount = Object.fromEntries(
-      Object.entries(merged.ui.onboarding.nudgeDismissCount).flatMap(([key, value]) => {
-        const normalizedKey = asString(key);
-        if (!normalizedKey || !Number.isFinite(value)) {
-          return [];
+      Object.entries(merged.ui.onboarding.nudgeDismissCount).flatMap(
+        ([key, value]) => {
+          const normalizedKey = asString(key);
+          if (!normalizedKey || !Number.isFinite(value)) {
+            return [];
+          }
+          return [[normalizedKey, Number(value)]];
         }
-        return [[normalizedKey, Number(value)]];
-      })
+      )
     );
   }
   if (typeof merged.ui.onboarding.proUnlockedCelebrated !== "boolean") {
@@ -2839,17 +2970,21 @@ function normalizeAppState(raw) {
     merged.ui.projectThreadSelections = {};
   } else {
     merged.ui.projectThreadSelections = Object.fromEntries(
-      Object.entries(merged.ui.projectThreadSelections).flatMap(([projectId, threadId]) => {
-        const normalizedProjectId = asString(projectId);
-        if (!normalizedProjectId) {
-          return [];
+      Object.entries(merged.ui.projectThreadSelections).flatMap(
+        ([projectId, threadId]) => {
+          const normalizedProjectId = asString(projectId);
+          if (!normalizedProjectId) {
+            return [];
+          }
+          const normalizedThreadId = typeof threadId === "string" && threadId.trim().length > 0 ? threadId.trim() : null;
+          return [[normalizedProjectId, normalizedThreadId]];
         }
-        const normalizedThreadId = typeof threadId === "string" && threadId.trim().length > 0 ? threadId.trim() : null;
-        return [[normalizedProjectId, normalizedThreadId]];
-      })
+      )
     );
   }
-  merged.ui.duplicateWarningDismissedKey = asString(merged.ui.duplicateWarningDismissedKey);
+  merged.ui.duplicateWarningDismissedKey = asString(
+    merged.ui.duplicateWarningDismissedKey
+  );
   if (typeof merged.ui.pendingLicenseActivation !== "boolean") {
     merged.ui.pendingLicenseActivation = false;
   }
@@ -2868,14 +3003,16 @@ function normalizeAppState(raw) {
     merged.profileDashboard.customGroupsByAccountKey = {};
   } else {
     merged.profileDashboard.customGroupsByAccountKey = Object.fromEntries(
-      Object.entries(merged.profileDashboard.customGroupsByAccountKey).flatMap(([key, value]) => {
-        const normalizedKey = asString(key);
-        const normalizedValue = asString(value);
-        if (!normalizedKey || !normalizedValue) {
-          return [];
+      Object.entries(merged.profileDashboard.customGroupsByAccountKey).flatMap(
+        ([key, value]) => {
+          const normalizedKey = asString(key);
+          const normalizedValue = asString(value);
+          if (!normalizedKey || !normalizedValue) {
+            return [];
+          }
+          return [[normalizedKey, normalizedValue]];
         }
-        return [[normalizedKey, normalizedValue]];
-      })
+      )
     );
   }
   {
@@ -2942,7 +3079,9 @@ function normalizeAppState(raw) {
   }
   merged.analytics.anonymousId = asString(merged.analytics.anonymousId);
   if (!merged.analytics.anonymousId) {
-    const legacyInstallId = asString(merged.telemetry?.installId);
+    const legacyInstallId = asString(
+      merged.telemetry?.installId
+    );
     merged.analytics.anonymousId = legacyInstallId;
   }
   if (typeof merged.analytics.enabled !== "boolean") {
@@ -3013,16 +3152,55 @@ async function readLegacyAppStateFromDisk() {
   }
 }
 async function readAppStateFromStorage() {
-  return readDocument(resolveStorageDbPath(), APP_STATE_DOCUMENT, normalizeAppState);
+  return readDocumentStrict(
+    resolveStorageDbPath(),
+    APP_STATE_DOCUMENT,
+    normalizeAppState
+  );
 }
 async function writeAppStateToStorage(state) {
-  return writeDocument(resolveStorageDbPath(), APP_STATE_DOCUMENT, normalizeAppState(state));
+  return writeDocument(
+    resolveStorageDbPath(),
+    APP_STATE_DOCUMENT,
+    normalizeAppState(state)
+  );
+}
+function compactRecoveryMessage(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : String(error);
+  return message.replace(/\s+/g, " ").trim().slice(0, 240) || "unknown corruption";
+}
+async function recoverCorruptAppStateStorage(error) {
+  const dbPath = resolveStorageDbPath();
+  if (error instanceof AppStorageCorruptionError && error.namespace === APP_STATE_DOCUMENT) {
+    appStateCache = null;
+    resetAppStorageInitialization(dbPath);
+    const legacyState2 = await readLegacyAppStateFromDisk().catch(() => null);
+    const recovered2 = normalizeAppState(legacyState2 ?? null);
+    recovered2.migration.lastError = `Recovered app-state document after corruption (${compactRecoveryMessage(error)}). Shared storage database preserved.`;
+    return writeAppStateToStorage(recovered2);
+  }
+  const backupPath = await backupCorruptAppStorageDb(dbPath);
+  appStateCache = null;
+  resetAppStorageInitialization(dbPath);
+  const legacyState = await readLegacyAppStateFromDisk().catch(() => null);
+  const recovered = normalizeAppState(legacyState ?? null);
+  recovered.migration.lastError = backupPath ? `Recovered app-state storage after corruption (${compactRecoveryMessage(error)}). Backup: ${import_node_path2.default.basename(backupPath)}` : `Recovered app-state storage after corruption (${compactRecoveryMessage(error)}). No existing DB file was present.`;
+  return writeAppStateToStorage(recovered);
 }
 async function ensureInitialized() {
   if (appStateCache) {
     return appStateCache;
   }
-  const loaded = await readAppStateFromStorage() ?? await readLegacyAppStateFromDisk();
+  let loaded = null;
+  try {
+    loaded = await readAppStateFromStorage() ?? await readLegacyAppStateFromDisk();
+  } catch (error) {
+    if (!isAppStorageCorruptionError(error)) {
+      throw error;
+    }
+    appStateCache = await recoverCorruptAppStateStorage(error);
+    return clone2(appStateCache);
+  }
   const normalized = loaded ?? normalizeAppState(null);
   appStateCache = await writeAppStateToStorage(normalized);
   return clone2(appStateCache);
@@ -3046,7 +3224,11 @@ async function withWriteLock(task) {
   }
 }
 async function initializeAppState(userDataDir) {
-  configuredUserDataDir = userDataDir;
+  if (configuredUserDataDir !== userDataDir) {
+    configuredUserDataDir = userDataDir;
+    appStateCache = null;
+    resetAppStorageInitialization(resolveStorageDbPath());
+  }
   const state = await ensureInitialized();
   return clone2(state);
 }
@@ -4037,8 +4219,125 @@ function logInfo(...args) {
 
 // ../../packages/runtime-codex/src/codex/rpc.ts
 var RPC_TIMEOUT_MS = 1e4;
+var ACTIVATION_TURN_TIMEOUT_MS = 9e4;
+var ACTIVATION_PROMPT = "Reply with exactly: ok.";
+var ACTIVATION_MODEL = "gpt-5.1-codex-mini";
 var MAX_STDERR_CAPTURE_CHARS = 32768;
 var REFRESH_TOKEN_REDEEMED_SNIPPET = "refresh token was already used";
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function asString3(value) {
+  return typeof value === "string" ? value : value != null ? String(value) : "";
+}
+function createRpcMessageReader(rl) {
+  const queue = [];
+  const waiters = [];
+  let closedError = null;
+  const rejectAll = (error) => {
+    closedError = error;
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      clearTimeout(waiter.timer);
+      waiter.reject(error);
+    }
+  };
+  const onLine = (line) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      rejectAll(new Error("codex RPC returned malformed JSON"));
+      return;
+    }
+    const waiterIndex = waiters.findIndex((waiter) => waiter.predicate(parsed));
+    if (waiterIndex >= 0) {
+      const [waiter] = waiters.splice(waiterIndex, 1);
+      clearTimeout(waiter.timer);
+      waiter.resolve(parsed);
+      return;
+    }
+    queue.push(parsed);
+  };
+  const onClose = () => {
+    rejectAll(new Error("codex RPC stream closed before response"));
+  };
+  rl.on("line", onLine);
+  rl.on("close", onClose);
+  return {
+    read(predicate, timeoutMs) {
+      const queuedIndex = queue.findIndex(predicate);
+      if (queuedIndex >= 0) {
+        const [message] = queue.splice(queuedIndex, 1);
+        return Promise.resolve(message);
+      }
+      if (closedError) {
+        return Promise.reject(closedError);
+      }
+      return new Promise((resolve, reject) => {
+        const waiter = {
+          predicate,
+          resolve,
+          reject,
+          timer: setTimeout(
+            () => {
+              const index = waiters.indexOf(waiter);
+              if (index >= 0) {
+                waiters.splice(index, 1);
+              }
+              reject(new Error("codex RPC timed out"));
+            },
+            Math.max(1, timeoutMs)
+          )
+        };
+        waiters.push(waiter);
+      });
+    },
+    dispose() {
+      rl.off("line", onLine);
+      rl.off("close", onClose);
+      while (waiters.length > 0) {
+        const waiter = waiters.shift();
+        clearTimeout(waiter.timer);
+      }
+    }
+  };
+}
+function readThreadIdFromResult(result) {
+  if (!isRecord4(result)) return null;
+  const thread = isRecord4(result.thread) ? result.thread : {};
+  const value = asString3(thread.id ?? result.threadId).trim();
+  return value.length > 0 ? value : null;
+}
+function readTurnIdFromResult(result) {
+  if (!isRecord4(result)) return null;
+  const turn = isRecord4(result.turn) ? result.turn : {};
+  const value = asString3(turn.id ?? result.turnId).trim();
+  return value.length > 0 ? value : null;
+}
+function readTurnIdFromNotification(message) {
+  if (!isRecord4(message.params)) return null;
+  const turn = isRecord4(message.params.turn) ? message.params.turn : {};
+  const value = asString3(turn.id ?? message.params.turnId).trim();
+  return value.length > 0 ? value : null;
+}
+function readTurnStatusFromNotification(message) {
+  if (!isRecord4(message.params)) {
+    return { status: null, reason: null };
+  }
+  const turn = isRecord4(message.params.turn) ? message.params.turn : {};
+  const error = isRecord4(turn.error) ? turn.error : null;
+  return {
+    status: asString3(turn.status).trim() || null,
+    reason: error ? asString3(error.message).trim() || null : null
+  };
+}
+function readLegacyEventTurnId(message) {
+  if (!isRecord4(message.params)) return null;
+  const msg = isRecord4(message.params.msg) ? message.params.msg : {};
+  const value = asString3(message.params.id ?? msg.turn_id ?? msg.turnId).trim();
+  return value.length > 0 ? value : null;
+}
 function parseTimestamp2(value) {
   if (typeof value !== "string" || value.trim().length === 0) {
     return null;
@@ -4089,8 +4388,17 @@ function extractAuthRecencyMs(content) {
   const rootLastRefresh = parseTimestamp2(parsed.last_refresh);
   const nestedLastRefresh = parseTimestamp2(parsed.tokens?.last_refresh);
   const rootAccessIssuedAt = extractJwtIssuedAtMs(parsed.access_token);
-  const nestedAccessIssuedAt = extractJwtIssuedAtMs(parsed.tokens?.access_token);
-  const candidates = [rootLastRefresh, nestedLastRefresh, rootAccessIssuedAt, nestedAccessIssuedAt].filter((value) => typeof value === "number" && Number.isFinite(value));
+  const nestedAccessIssuedAt = extractJwtIssuedAtMs(
+    parsed.tokens?.access_token
+  );
+  const candidates = [
+    rootLastRefresh,
+    nestedLastRefresh,
+    rootAccessIssuedAt,
+    nestedAccessIssuedAt
+  ].filter(
+    (value) => typeof value === "number" && Number.isFinite(value)
+  );
   if (candidates.length === 0) {
     return null;
   }
@@ -4141,10 +4449,13 @@ function isRpcResponseForRequest(message, requestId) {
 }
 async function readRpcResponseById(rl, requestId, timeoutMs) {
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      cleanup();
-      reject(new Error("codex RPC timed out"));
-    }, Math.max(1, timeoutMs));
+    const timer = setTimeout(
+      () => {
+        cleanup();
+        reject(new Error("codex RPC timed out"));
+      },
+      Math.max(1, timeoutMs)
+    );
     const cleanup = () => {
       clearTimeout(timer);
       rl.off("line", onLine);
@@ -4294,7 +4605,11 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
       throw new Error(formatRpcError("initialize", initializeResponse.error));
     }
     await sendPayload(child, { method: "initialized", params: {} });
-    await sendPayload(child, { id: 2, method: "account/rateLimits/read", params: {} });
+    await sendPayload(child, {
+      id: 2,
+      method: "account/rateLimits/read",
+      params: {}
+    });
     const message = await readRpcResponseById(rl, 2, RPC_TIMEOUT_MS);
     if (message.error) {
       const base = formatRpcError("account/rateLimits/read", message.error);
@@ -4315,11 +4630,181 @@ async function fetchRateLimitsViaRpc(envOverride, options = {}) {
         if (shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth)) {
           await import_node_fs5.promises.writeFile(sourceAuthPath, updatedAuth, "utf8");
         } else if (currentSourceAuth && currentSourceAuth !== updatedAuth && currentSourceAuth !== initialSourceAuth) {
-          logWarn("Skipped stale auth sync-back after rate-limit probe; source auth changed in flight.", {
-            sourceAuthPath,
-            currentRecencyMs: extractAuthRecencyMs(currentSourceAuth),
-            updatedRecencyMs: extractAuthRecencyMs(updatedAuth)
-          });
+          logWarn(
+            "Skipped stale auth sync-back after rate-limit probe; source auth changed in flight.",
+            {
+              sourceAuthPath,
+              currentRecencyMs: extractAuthRecencyMs(currentSourceAuth),
+              updatedRecencyMs: extractAuthRecencyMs(updatedAuth)
+            }
+          );
+        }
+      }
+    } catch {
+    }
+    await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function activateResetWindowViaRpc(envOverride, options = {}) {
+  const binaryPath = options.codexPath ?? await requireCodexCli();
+  const tempHome = await import_node_fs5.promises.mkdtemp(
+    import_node_path6.default.join(import_node_os2.default.tmpdir(), "codex-activation-")
+  );
+  const tempAuthPath = import_node_path6.default.join(tempHome, "auth.json");
+  let initialSourceAuth = null;
+  const sourceAuthPath = options.authPath ?? (envOverride?.CODEX_HOME ? import_node_path6.default.join(envOverride.CODEX_HOME, "auth.json") : import_node_path6.default.join(
+    envOverride?.HOME ?? process.env.HOME ?? process.env.USERPROFILE ?? import_node_os2.default.homedir(),
+    ".codex",
+    "auth.json"
+  ));
+  try {
+    initialSourceAuth = await import_node_fs5.promises.readFile(sourceAuthPath, "utf8").catch(() => null);
+    if (!initialSourceAuth) {
+      await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+      });
+      return { status: "skipped", reason: "auth-missing" };
+    }
+    await import_node_fs5.promises.writeFile(tempAuthPath, initialSourceAuth, "utf8");
+  } catch {
+    await import_node_fs5.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    });
+    return { status: "skipped", reason: "auth-missing" };
+  }
+  const childEnv = {
+    ...process.env,
+    ...envOverride ?? {},
+    HOME: tempHome,
+    USERPROFILE: tempHome,
+    CODEX_HOME: tempHome,
+    CODEX_TELEMETRY_LABEL: "codex-reset-activation",
+    ELECTRON_RUN_AS_NODE: "1"
+  };
+  const command = buildCodexCommand(
+    binaryPath,
+    ["-s", "read-only", "-a", "untrusted", "app-server"],
+    childEnv
+  );
+  const child = (0, import_node_child_process2.spawn)(command.command, command.args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: childEnv,
+    shell: command.shell
+  });
+  const rl = import_node_readline.default.createInterface({
+    input: child.stdout,
+    crlfDelay: Infinity
+  });
+  const reader = createRpcMessageReader(rl);
+  let stderrOutput = "";
+  child.stderr?.on("data", (chunk) => {
+    if (stderrOutput.length >= MAX_STDERR_CAPTURE_CHARS) {
+      return;
+    }
+    const text = chunk.toString("utf8");
+    const remaining = MAX_STDERR_CAPTURE_CHARS - stderrOutput.length;
+    stderrOutput += text.slice(0, Math.max(0, remaining));
+  });
+  try {
+    await sendPayload(child, {
+      id: 1,
+      method: "initialize",
+      params: { clientInfo: { name: "codexuse", version: "0.0.0" } }
+    });
+    const initializeResponse = await reader.read(
+      (message) => isRpcResponseForRequest(message, 1),
+      RPC_TIMEOUT_MS
+    );
+    if (initializeResponse.error) {
+      throw new Error(formatRpcError("initialize", initializeResponse.error));
+    }
+    await sendPayload(child, { method: "initialized", params: {} });
+    await sendPayload(child, {
+      id: 2,
+      method: "thread/start",
+      params: {
+        cwd: tempHome,
+        model: ACTIVATION_MODEL,
+        approvalPolicy: "untrusted",
+        sandbox: "read-only",
+        experimentalRawEvents: false
+      }
+    });
+    const threadResponse = await reader.read(
+      (message) => isRpcResponseForRequest(message, 2),
+      RPC_TIMEOUT_MS
+    );
+    if (threadResponse.error) {
+      throw new Error(formatRpcError("thread/start", threadResponse.error));
+    }
+    const threadId = readThreadIdFromResult(threadResponse.result);
+    if (!threadId) {
+      throw new Error("thread/start response did not include a thread id.");
+    }
+    await sendPayload(child, {
+      id: 3,
+      method: "turn/start",
+      params: {
+        threadId,
+        model: ACTIVATION_MODEL,
+        effort: "low",
+        input: [
+          {
+            type: "text",
+            text: ACTIVATION_PROMPT,
+            text_elements: []
+          }
+        ]
+      }
+    });
+    const turnResponse = await reader.read(
+      (message) => isRpcResponseForRequest(message, 3),
+      RPC_TIMEOUT_MS
+    );
+    if (turnResponse.error) {
+      const base = formatRpcError("turn/start", turnResponse.error);
+      const hint = inferRefreshFailureHint(stderrOutput);
+      if (hint && !base.toLowerCase().includes(hint)) {
+        throw new Error(`${base}; ${hint}`);
+      }
+      throw new Error(base);
+    }
+    const turnId = readTurnIdFromResult(turnResponse.result);
+    if (!turnId) {
+      throw new Error("turn/start response did not include a turn id.");
+    }
+    const completed = await reader.read(
+      (message) => message.method === "turn/completed" && readTurnIdFromNotification(message) === turnId || message.method === "codex/event/task_complete" && readLegacyEventTurnId(message) === turnId,
+      ACTIVATION_TURN_TIMEOUT_MS
+    );
+    const turnStatus = readTurnStatusFromNotification(completed);
+    if (turnStatus.status === "failed") {
+      return {
+        status: "failed",
+        reason: turnStatus.reason ?? "turn-failed",
+        threadId,
+        turnId
+      };
+    }
+    return { status: "completed", reason: null, threadId, turnId };
+  } finally {
+    child.kill();
+    reader.dispose();
+    rl.close();
+    try {
+      const updatedAuth = await import_node_fs5.promises.readFile(tempAuthPath, "utf8");
+      if (updatedAuth.trim().length > 0) {
+        const currentSourceAuth = await import_node_fs5.promises.readFile(sourceAuthPath, "utf8").catch(() => null);
+        if (shouldWriteBackAuth(initialSourceAuth, currentSourceAuth, updatedAuth)) {
+          await import_node_fs5.promises.writeFile(sourceAuthPath, updatedAuth, "utf8");
+        } else if (currentSourceAuth && currentSourceAuth !== updatedAuth && currentSourceAuth !== initialSourceAuth) {
+          logWarn(
+            "Skipped stale auth sync-back after reset-window activation; source auth changed in flight.",
+            {
+              sourceAuthPath,
+              currentRecencyMs: extractAuthRecencyMs(currentSourceAuth),
+              updatedRecencyMs: extractAuthRecencyMs(updatedAuth)
+            }
+          );
         }
       }
     } catch {
@@ -5868,6 +6353,25 @@ var ProfileManager = class {
       });
     }
   }
+  async activateResetWindow(name, options = {}) {
+    const profileName = this.normalizeProfileName(name);
+    try {
+      return await this.enqueueProfileOperation(
+        profileName,
+        () => this.runWithPreparedProfileHome(
+          profileName,
+          (env) => activateResetWindowViaRpc(env, { codexPath: options.codexPath }),
+          { syncFromActiveAuthBeforeAction: false }
+        )
+      );
+    } finally {
+      await this.enqueueAuthSwap(async () => {
+        await this.syncActiveAuthFromProfileIfCurrent(profileName);
+      }).catch((error) => {
+        logWarn(`Failed to sync active auth after reset-window activation for '${profileName}':`, error);
+      });
+    }
+  }
   /**
    * Rename a profile
    */
@@ -6320,7 +6824,7 @@ var MODEL_SLUG_ALIASES = {
 function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function asString3(value) {
+function asString4(value) {
   if (typeof value !== "string") {
     return null;
   }
@@ -6331,7 +6835,7 @@ function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function normalizeIsoString(value) {
-  const normalized = asString3(value);
+  const normalized = asString4(value);
   if (!normalized) {
     return null;
   }
@@ -6343,7 +6847,7 @@ function normalizeStringArray(value) {
   const result = [];
   const seen = /* @__PURE__ */ new Set();
   for (const entry of input) {
-    const normalized = asString3(entry);
+    const normalized = asString4(entry);
     if (!normalized || seen.has(normalized)) {
       continue;
     }
@@ -6353,7 +6857,7 @@ function normalizeStringArray(value) {
   return result;
 }
 function normalizeReasoningEffort(value) {
-  const normalized = asString3(value)?.toLowerCase() ?? null;
+  const normalized = asString4(value)?.toLowerCase() ?? null;
   return normalized && normalized.length > 0 ? normalized : null;
 }
 function normalizeRoutingStrategy(value) {
@@ -6387,7 +6891,7 @@ function normalizeAccountPoolExposedModels(value, fallbackToDefault) {
   const seen = /* @__PURE__ */ new Set();
   const input = Array.isArray(value) ? value : [];
   for (const entry of input) {
-    const raw = asString3(entry);
+    const raw = asString4(entry);
     const normalized = normalizeCodexModelSlug(raw) ?? raw;
     if (!normalized || seen.has(normalized)) {
       continue;
@@ -6503,8 +7007,8 @@ function normalizeSessionStatus(value) {
 }
 function normalizeApiKeyRecord(id, value) {
   const record = asRecord2(value);
-  const tokenHash = asString3(record.tokenHash);
-  const tokenPreview = asString3(record.tokenPreview);
+  const tokenHash = asString4(record.tokenHash);
+  const tokenPreview = asString4(record.tokenPreview);
   const createdAt = normalizeIsoString(record.createdAt);
   if (!tokenHash || !tokenPreview || !createdAt) {
     return null;
@@ -6520,7 +7024,7 @@ function normalizeApiKeyRecord(id, value) {
 }
 function normalizeLegacySessionRecord(id, value) {
   const record = asRecord2(value);
-  const profileName = asString3(record.profileName);
+  const profileName = asString4(record.profileName);
   const createdAt = normalizeIsoString(record.createdAt);
   const lastUsedAt = normalizeIsoString(record.lastUsedAt);
   if (!profileName || !createdAt || !lastUsedAt) {
@@ -6530,16 +7034,16 @@ function normalizeLegacySessionRecord(id, value) {
   return {
     id,
     affinityKind,
-    affinityKey: asString3(record.affinityKey),
+    affinityKey: asString4(record.affinityKey),
     profileName,
-    threadId: asString3(record.threadId) ?? id,
-    model: asString3(record.model),
+    threadId: asString4(record.threadId) ?? id,
+    model: asString4(record.model),
     status: normalizeSessionStatus(record.status),
-    lastError: asString3(record.lastError),
+    lastError: asString4(record.lastError),
     createdAt,
     lastUsedAt,
     expiresAt: normalizeIsoString(record.expiresAt),
-    lastResponseId: asString3(record.lastResponseId),
+    lastResponseId: asString4(record.lastResponseId),
     responseIds: normalizeStringArray(record.responseIds).slice(0, MAX_RESPONSE_IDS_PER_SESSION)
   };
 }
@@ -6561,7 +7065,7 @@ function normalizeLegacyStore(value) {
   }
   const responseIndex = {};
   for (const [responseId, sessionId] of Object.entries(asRecord2(record.responseIndex))) {
-    const normalizedSessionId = asString3(sessionId);
+    const normalizedSessionId = asString4(sessionId);
     if (normalizedSessionId) {
       responseIndex[responseId] = normalizedSessionId;
     }
@@ -6576,7 +7080,7 @@ function normalizeLegacyStore(value) {
 }
 function normalizeSessionRecord(id, value) {
   const record = asRecord2(value);
-  const activeSegmentId = asString3(record.activeSegmentId);
+  const activeSegmentId = asString4(record.activeSegmentId);
   const createdAt = normalizeIsoString(record.createdAt);
   const lastUsedAt = normalizeIsoString(record.lastUsedAt);
   if (!activeSegmentId || !createdAt || !lastUsedAt) {
@@ -6586,25 +7090,25 @@ function normalizeSessionRecord(id, value) {
   return {
     id,
     affinityKind,
-    affinityKey: asString3(record.affinityKey),
+    affinityKey: asString4(record.affinityKey),
     activeSegmentId,
     segmentIds: normalizeStringArray(record.segmentIds),
-    model: asString3(record.model),
+    model: asString4(record.model),
     status: normalizeSessionStatus(record.status),
-    lastError: asString3(record.lastError),
+    lastError: asString4(record.lastError),
     createdAt,
     lastUsedAt,
     expiresAt: normalizeIsoString(record.expiresAt),
-    lastResponseId: asString3(record.lastResponseId),
+    lastResponseId: asString4(record.lastResponseId),
     responseIds: normalizeStringArray(record.responseIds).slice(0, MAX_RESPONSE_IDS_PER_SESSION),
     rolloverCount: asNumber(record.rolloverCount) ?? 0,
-    lastRolloverReason: asString3(record.lastRolloverReason)
+    lastRolloverReason: asString4(record.lastRolloverReason)
   };
 }
 function normalizeSegmentRecord(id, value) {
   const record = asRecord2(value);
-  const sessionId = asString3(record.sessionId);
-  const profileName = asString3(record.profileName);
+  const sessionId = asString4(record.sessionId);
+  const profileName = asString4(record.profileName);
   const createdAt = normalizeIsoString(record.createdAt);
   const lastUsedAt = normalizeIsoString(record.lastUsedAt);
   if (!sessionId || !profileName || !createdAt || !lastUsedAt) {
@@ -6620,8 +7124,8 @@ function normalizeSegmentRecord(id, value) {
 }
 function normalizeResponseIndexRecord(value) {
   const record = asRecord2(value);
-  const sessionId = asString3(record.sessionId);
-  const segmentId = asString3(record.segmentId);
+  const sessionId = asString4(record.sessionId);
+  const segmentId = asString4(record.segmentId);
   const createdAt = normalizeIsoString(record.createdAt) ?? (/* @__PURE__ */ new Date(0)).toISOString();
   if (!sessionId || !segmentId) {
     return null;
@@ -7296,7 +7800,7 @@ async function handleAccountPoolCommand(args, version) {
         params,
         key: "accountPoolExposedModels",
         defaultValues: DEFAULT_ACCOUNT_POOL_EXPOSED_MODELS,
-        normalizeValue: (value) => normalizeCodexModelSlug(value) ?? asString3(value)
+        normalizeValue: (value) => normalizeCodexModelSlug(value) ?? asString4(value)
       });
       return;
     case "reasoning":
@@ -8653,228 +9157,227 @@ async function getOfficialCodexProfileInstances() {
   };
 }
 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,
+  return enqueueProfileAction(() => launchOfficialCodexProfileInstanceOnce(options));
+}
+async function launchOfficialCodexProfileInstanceOnce(options) {
+  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: "failed",
-        lastError: "app-server-not-verified"
+        lastStatus: "already-running",
+        lastError: null
       };
-      await patchManagedInstance(failed);
+      await patchManagedInstance(verified);
       return {
-        status: "failed",
+        status: "already-running",
         profileName: options.profileName,
-        instance: managedInstanceToPayload(failed, false),
-        reason: "app-server-not-verified"
+        instance: managedInstanceToPayload(
+          verified,
+          true,
+          runtime.appServerPid,
+          runtime.startedAt
+        ),
+        reason: null
       };
     }
-    const now = Date.now();
-    const instance = {
+  }
+  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: launchedPid,
-      appServerPid,
-      launchedAt: now,
-      lastVerifiedAt: now,
-      lastStatus: "started",
-      lastError: null
+      pid: null,
+      appServerPid: null,
+      launchedAt: null,
+      lastVerifiedAt: null,
+      lastStatus: "failed",
+      lastError: "open-failed"
     };
-    await patchManagedInstance(instance);
+    await patchManagedInstance(failed);
     return {
-      status: "started",
+      status: "failed",
       profileName: options.profileName,
-      instance: managedInstanceToPayload(instance, true, appServerPid),
-      reason: null
+      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 = {
+async function stopOfficialCodexProfileInstanceOnce(profileName) {
+  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: stillRunning ? existing.pid : null,
-      appServerPid: stillRunning ? runtime.appServerPid : null,
+      pid: null,
+      appServerPid: null,
       lastVerifiedAt: Date.now(),
-      lastStatus: stillRunning ? "failed" : "stopped",
-      lastError: stillRunning ? "stop-timeout" : null
+      lastStatus: "not-running",
+      lastError: "official-codex-app-not-found"
     };
-    await patchManagedInstance(stopped);
+    await patchManagedInstance(stopped2);
     return {
-      status: stillRunning ? "failed" : "stopped",
+      status: "not-running",
       profileName,
-      instance: managedInstanceToPayload(
-        stopped,
-        stillRunning,
-        stopped.appServerPid,
-        runtime.startedAt
-      ),
-      reason: stillRunning ? "stop-timeout" : null
+      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 () => {
@@ -8930,15 +9433,17 @@ function stopOfficialCodexObservedProfileInstance(profileName, pid, appServerPid
   });
 }
 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
-  };
+  return enqueueProfileAction(async () => {
+    const stopped = await stopOfficialCodexProfileInstanceOnce(options.profileName);
+    if (stopped.status === "failed") {
+      return stopped;
+    }
+    const launched = await launchOfficialCodexProfileInstanceOnce(options);
+    return {
+      ...launched,
+      status: launched.status === "started" ? "restarted" : launched.status
+    };
+  });
 }
 
 // src/commands/profile.ts
@@ -9941,7 +10446,7 @@ var import_node_path15 = __toESM(require("path"), 1);
 var CLOUD_SYNC_SCHEMA_VERSION = 1;
 
 // ../../packages/shared/src/core/type-guards.ts
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function toIsoOrNull(value) {
@@ -9979,10 +10484,10 @@ function buildSyncUrl(pathname) {
   return `${baseUrl}${normalizedPath}`;
 }
 function normalizeSnapshot(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return null;
   }
-  if (isRecord4(value.snapshot)) {
+  if (isRecord5(value.snapshot)) {
     const nested = normalizeSnapshot(value.snapshot);
     if (nested) {
       return nested;
@@ -9997,9 +10502,9 @@ function normalizeSnapshot(value) {
     return null;
   }
   const rawProfiles = Array.isArray(value.profiles) ? value.profiles : [];
-  const profiles = rawProfiles.map((entry) => isRecord4(entry) ? entry : null).filter((entry) => Boolean(entry)).map((entry) => {
-    const data = isRecord4(entry.data) ? entry.data : {};
-    const metadata = isRecord4(entry.metadata) ? entry.metadata : void 0;
+  const profiles = rawProfiles.map((entry) => isRecord5(entry) ? entry : null).filter((entry) => Boolean(entry)).map((entry) => {
+    const data = isRecord5(entry.data) ? entry.data : {};
+    const metadata = isRecord5(entry.metadata) ? entry.metadata : void 0;
     return {
       name: typeof entry.name === "string" ? entry.name : "",
       displayName: typeof entry.displayName === "string" ? entry.displayName : null,
@@ -10015,7 +10520,7 @@ function normalizeSnapshot(value) {
     };
   }).filter((entry) => entry.name.trim().length > 0);
   const rawSettings = value.settingsJson;
-  const settingsJson = isRecord4(rawSettings) ? rawSettings : null;
+  const settingsJson = isRecord5(rawSettings) ? rawSettings : null;
   return {
     schemaVersion: CLOUD_SYNC_SCHEMA_VERSION,
     updatedAt,
@@ -10199,7 +10704,7 @@ var FALLBACK_FEATURE_KEYS = [
 ];
 var metadataCache = null;
 var metadataCacheAt = 0;
-function isRecord5(value) {
+function isRecord6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function uniqueSorted(values) {
@@ -10264,16 +10769,16 @@ function parseFeatureCatalog(output) {
 }
 function parseSchemaKeys(schemaRaw) {
   const parsed = JSON.parse(schemaRaw);
-  if (!isRecord5(parsed)) {
+  if (!isRecord6(parsed)) {
     return {
       topLevelKeys: FALLBACK_SCHEMA_TOP_LEVEL_KEYS,
       featureKeys: FALLBACK_FEATURE_KEYS
     };
   }
-  const properties = isRecord5(parsed.properties) ? parsed.properties : {};
+  const properties = isRecord6(parsed.properties) ? parsed.properties : {};
   const topLevelKeys = uniqueSorted(Object.keys(properties));
-  const features = isRecord5(properties.features) ? properties.features : {};
-  const featureProperties = isRecord5(features.properties) ? features.properties : {};
+  const features = isRecord6(properties.features) ? properties.features : {};
+  const featureProperties = isRecord6(features.properties) ? features.properties : {};
   const featureKeys = uniqueSorted(Object.keys(featureProperties));
   return {
     topLevelKeys: topLevelKeys.length > 0 ? topLevelKeys : FALLBACK_SCHEMA_TOP_LEVEL_KEYS,
@@ -11059,15 +11564,15 @@ var SYNC_SIZE_WARN_BYTES = 1 * 1024 * 1024;
 var SYNC_SIZE_MAX_BYTES = 5 * 1024 * 1024;
 var MB_DIVISOR = 1024 * 1024;
 function mapProfilesFromAppState(raw) {
-  if (!isRecord4(raw)) {
+  if (!isRecord5(raw)) {
     return [];
   }
   const profiles = [];
   for (const [name, value] of Object.entries(raw)) {
-    if (!isRecord4(value)) {
+    if (!isRecord5(value)) {
       continue;
     }
-    const data = isRecord4(value.data) ? value.data : null;
+    const data = isRecord5(value.data) ? value.data : null;
     if (!data) {
       continue;
     }
@@ -11079,7 +11584,7 @@ function mapProfilesFromAppState(raw) {
       name: normalizedName,
       displayName: typeof value.displayName === "string" ? value.displayName : null,
       data,
-      metadata: isRecord4(value.metadata) ? value.metadata : void 0,
+      metadata: isRecord5(value.metadata) ? value.metadata : void 0,
       accountId: typeof value.accountId === "string" ? value.accountId : null,
       workspaceId: typeof value.workspaceId === "string" ? value.workspaceId : null,
       workspaceName: typeof value.workspaceName === "string" ? value.workspaceName : null,
@@ -11093,7 +11598,7 @@ function mapProfilesFromAppState(raw) {
 }
 function summarizeSnapshot(snapshot) {
   const configBytes = typeof snapshot.configTomlContent === "string" ? snapshot.configTomlContent.length : 0;
-  const settingsKeys = isRecord4(snapshot.settingsJson) ? Object.keys(snapshot.settingsJson).length : 0;
+  const settingsKeys = isRecord5(snapshot.settingsJson) ? Object.keys(snapshot.settingsJson).length : 0;
   return {
     profiles: snapshot.profiles.length,
     configBytes,
@@ -11198,7 +11703,7 @@ async function buildLocalSnapshot(profileManager, options = {}) {
   const settingsJson = await readCodexSettingsJsonRaw();
   const hasProfiles = profiles.length > 0;
   const hasConfig = typeof config.content === "string" && config.content.trim().length > 0;
-  const hasSettings = isRecord4(settingsJson) && Object.keys(settingsJson).length > 0;
+  const hasSettings = isRecord5(settingsJson) && Object.keys(settingsJson).length > 0;
   if (enforcePushGuards && !hasProfiles && !hasConfig && !hasSettings) {
     throw new Error("Refusing to push an empty cloud sync snapshot.");
   }
@@ -11222,7 +11727,7 @@ async function applyRemoteSnapshot(profileManager, snapshot) {
       codexHomePath: runtimeContext.codexHomePath
     });
   }
-  if (snapshot.settingsJson && isRecord4(snapshot.settingsJson)) {
+  if (snapshot.settingsJson && isRecord5(snapshot.settingsJson)) {
     await writeCodexSettingsJsonRaw(snapshot.settingsJson);
   } else {
     await writeCodexSettingsJsonRaw({});
@@ -11475,10 +11980,10 @@ var LEGACY_SKILL_CACHE_DIR = "skill-cache";
 var LEGACY_SKILLS_REPOS_FILE = "repos.json";
 var LEGACY_SKILL_MANIFEST = ".codexuse-skill.json";
 var LEGACY_LICENSE_SECRET_FILE2 = "license.secret";
-function isRecord6(value) {
+function isRecord7(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function asString4(value) {
+function asString5(value) {
   if (typeof value !== "string") {
     return null;
   }
@@ -11647,7 +12152,7 @@ function pickAutoRoll(raw) {
   }
 }
 function parseLegacyLicense(raw) {
-  if (!isRecord6(raw)) {
+  if (!isRecord7(raw)) {
     return {
       licenseKey: null,
       purchaseEmail: null,
@@ -11658,25 +12163,25 @@ function parseLegacyLicense(raw) {
       signature: null
     };
   }
-  const statusCandidate = asString4(raw.status);
+  const statusCandidate = asString5(raw.status);
   const status = ["inactive", "active", "grace", "error"].includes(statusCandidate ?? "") ? statusCandidate : "inactive";
   return {
-    licenseKey: asString4(raw.licenseKey ?? raw.license_key),
-    purchaseEmail: asString4(raw.purchaseEmail ?? raw.purchase_email),
-    lastVerifiedAt: asString4(raw.lastVerifiedAt ?? raw.last_verified_at),
-    nextCheckAt: asString4(raw.nextCheckAt ?? raw.next_check_at),
-    lastVerificationError: asString4(raw.lastVerificationError ?? raw.last_verification_error),
+    licenseKey: asString5(raw.licenseKey ?? raw.license_key),
+    purchaseEmail: asString5(raw.purchaseEmail ?? raw.purchase_email),
+    lastVerifiedAt: asString5(raw.lastVerifiedAt ?? raw.last_verified_at),
+    nextCheckAt: asString5(raw.nextCheckAt ?? raw.next_check_at),
+    lastVerificationError: asString5(raw.lastVerificationError ?? raw.last_verification_error),
     status,
-    signature: asString4(raw.signature)
+    signature: asString5(raw.signature)
   };
 }
 function parseLegacyProfileRecord(name, raw) {
-  if (!isRecord6(raw)) {
+  if (!isRecord7(raw)) {
     return null;
   }
   const dataRaw = raw.data;
   let data = null;
-  if (isRecord6(dataRaw)) {
+  if (isRecord7(dataRaw)) {
     data = dataRaw;
   } else if (typeof dataRaw === "string") {
     try {
@@ -11690,31 +12195,31 @@ function parseLegacyProfileRecord(name, raw) {
   }
   return {
     name,
-    displayName: asString4(raw.displayName ?? raw.display_name) ?? name,
+    displayName: asString5(raw.displayName ?? raw.display_name) ?? name,
     data,
-    metadata: isRecord6(raw.metadata) ? raw.metadata : void 0,
-    accountId: asString4(raw.accountId ?? raw.account_id),
-    workspaceId: asString4(raw.workspaceId ?? raw.workspace_id),
-    workspaceName: asString4(raw.workspaceName ?? raw.workspace_name),
-    email: asString4(raw.email),
-    authMethod: asString4(raw.authMethod ?? raw.auth_method),
-    createdAt: asString4(raw.createdAt ?? raw.created_at),
-    updatedAt: asString4(raw.updatedAt ?? raw.updated_at)
+    metadata: isRecord7(raw.metadata) ? raw.metadata : void 0,
+    accountId: asString5(raw.accountId ?? raw.account_id),
+    workspaceId: asString5(raw.workspaceId ?? raw.workspace_id),
+    workspaceName: asString5(raw.workspaceName ?? raw.workspace_name),
+    email: asString5(raw.email),
+    authMethod: asString5(raw.authMethod ?? raw.auth_method),
+    createdAt: asString5(raw.createdAt ?? raw.created_at),
+    updatedAt: asString5(raw.updatedAt ?? raw.updated_at)
   };
 }
 async function loadLegacySettingsPatch() {
   const filePath = resolveLegacyPath(LEGACY_SETTINGS_FILE);
   const raw = await readJsonFileIfExists(filePath);
-  if (!isRecord6(raw)) {
+  if (!isRecord7(raw)) {
     return {};
   }
   const autoRoll = pickAutoRoll(raw.autoRoll ?? raw.auto_roll);
   const license = parseLegacyLicense(raw.license ?? raw.license_data ?? raw.license_state);
   return {
     app: {
-      lastAppVersion: asString4(raw.lastAppVersion ?? raw.last_app_version),
-      pendingUpdateVersion: asString4(raw.pendingUpdateVersion ?? raw.pending_update_version),
-      lastProfileName: asString4(raw.lastProfileName ?? raw.last_profile_name)
+      lastAppVersion: asString5(raw.lastAppVersion ?? raw.last_app_version),
+      pendingUpdateVersion: asString5(raw.pendingUpdateVersion ?? raw.pending_update_version),
+      lastProfileName: asString5(raw.lastProfileName ?? raw.last_profile_name)
     },
     license,
     autoRoll: autoRoll ? {
@@ -11732,22 +12237,22 @@ async function loadLegacySettingsPatch() {
 async function loadLegacySyncPatch() {
   const filePath = resolveLegacyPath(LEGACY_SYNC_STATE_FILE);
   const raw = await readJsonFileIfExists(filePath);
-  if (!isRecord6(raw)) {
+  if (!isRecord7(raw)) {
     return {};
   }
   return {
     sync: {
-      lastPushAt: asString4(raw.lastPushAt),
-      lastPullAt: asString4(raw.lastPullAt),
-      lastError: asString4(raw.lastError),
-      remoteUpdatedAt: asString4(raw.remoteUpdatedAt)
+      lastPushAt: asString5(raw.lastPushAt),
+      lastPullAt: asString5(raw.lastPullAt),
+      lastError: asString5(raw.lastError),
+      remoteUpdatedAt: asString5(raw.remoteUpdatedAt)
     }
   };
 }
 async function loadLegacyAppSettingsParityPatch() {
   const filePath = import_node_path16.default.join(getUserDataDir(), LEGACY_APP_SETTINGS_PARITY_FILE);
   const raw = await readJsonFileIfExists(filePath);
-  if (!isRecord6(raw)) {
+  if (!isRecord7(raw)) {
     return {};
   }
   return {
@@ -11787,21 +12292,21 @@ async function loadLegacyProfilesPatch() {
   return { profilesByName };
 }
 function parseSkillInstallMetadata(raw) {
-  if (!isRecord6(raw)) {
+  if (!isRecord7(raw)) {
     return null;
   }
-  const id = asString4(raw.id);
+  const id = asString5(raw.id);
   if (!id) {
     return null;
   }
   return {
     id,
-    repo: asString4(raw.repo),
-    repoPath: asString4(raw.repoPath),
-    sourceLabel: asString4(raw.sourceLabel),
+    repo: asString5(raw.repo),
+    repoPath: asString5(raw.repoPath),
+    sourceLabel: asString5(raw.sourceLabel),
     sourceType: raw.sourceType === "official" || raw.sourceType === "community" || raw.sourceType === "local" ? raw.sourceType : void 0,
-    viewUrl: asString4(raw.viewUrl),
-    createdAt: asString4(raw.createdAt)
+    viewUrl: asString5(raw.viewUrl),
+    createdAt: asString5(raw.createdAt)
   };
 }
 async function loadLegacySkillsPatch() {
@@ -11832,7 +12337,7 @@ async function loadLegacySkillsPatch() {
     }
     installsBySlug[entry.name] = parsed;
   }
-  const sources = isRecord6(reposRaw) && Array.isArray(reposRaw.sources) ? reposRaw.sources : [];
+  const sources = isRecord7(reposRaw) && Array.isArray(reposRaw.sources) ? reposRaw.sources : [];
   if (sources.length === 0 && Object.keys(installsBySlug).length === 0) {
     return {};
   }
@@ -11864,7 +12369,7 @@ function mergeLegacyLocalStoragePatch(payload) {
     }
   };
   const settingsStorage = payload["settings-storage"];
-  if (isRecord6(settingsStorage)) {
+  if (isRecord7(settingsStorage)) {
     const nextExcludeFolders = Array.isArray(settingsStorage.excludeFolders) ? settingsStorage.excludeFolders.filter((item) => typeof item === "string") : void 0;
     const nextBeep = typeof settingsStorage.enableTaskCompleteBeep === "boolean" ? settingsStorage.enableTaskCompleteBeep : void 0;
     const nextSleep = typeof settingsStorage.preventSleepDuringTasks === "boolean" ? settingsStorage.preventSleepDuringTasks : void 0;
@@ -11883,15 +12388,15 @@ function mergeLegacyLocalStoragePatch(payload) {
   markSkippedIfPresent("provider", hasKey2("provider"));
   markSkippedIfPresent("sandbox-storage", hasKey2("sandbox-storage"));
   const projectSettings = payload["project-settings-storage"];
-  if (isRecord6(projectSettings) && isRecord6(projectSettings.settingsByPath)) {
+  if (isRecord7(projectSettings) && isRecord7(projectSettings.settingsByPath)) {
     patch.workspaceSettingsByPath = projectSettings.settingsByPath;
     markSkippedIfPresent("project-settings-storage", true);
   } else {
     markSkippedIfPresent("project-settings-storage", false);
   }
   const folder = payload["folder-storage"];
-  if (isRecord6(folder)) {
-    const folderHistory = Array.isArray(folder.folderHistory) ? folder.folderHistory.filter(isRecord6) : void 0;
+  if (isRecord7(folder)) {
+    const folderHistory = Array.isArray(folder.folderHistory) ? folder.folderHistory.filter(isRecord7) : void 0;
     const pinnedPaths = Array.isArray(folder.pinnedPaths) ? folder.pinnedPaths.filter((item) => typeof item === "string") : void 0;
     patch.preferences = {
       ...patch.preferences ?? {},
@@ -11904,12 +12409,12 @@ function mergeLegacyLocalStoragePatch(payload) {
   }
   const categories = payload["conversation-categories-storage"];
   let consumedCategories = false;
-  if (isRecord6(categories)) {
-    if (isRecord6(categories.categoriesByCwd)) {
+  if (isRecord7(categories)) {
+    if (isRecord7(categories.categoriesByCwd)) {
       patch.conversationCategoriesByCwd = categories.categoriesByCwd;
       consumedCategories = true;
     }
-    if (isRecord6(categories.conversationCategoryByCwd)) {
+    if (isRecord7(categories.conversationCategoryByCwd)) {
       patch.conversationCategoryAssignmentsByCwd = categories.conversationCategoryByCwd;
       consumedCategories = true;
     }
@@ -12132,7 +12637,7 @@ async function importLegacyLocalStorageOnce(payload) {
   if (current.migration.status === "pending") {
     return { completed: false, importedKeys: [], skippedKeys: [] };
   }
-  if (!payload || !isRecord6(payload)) {
+  if (!payload || !isRecord7(payload)) {
     return { completed: true, importedKeys: [], skippedKeys: [] };
   }
   const { patch, consumedKeys, skippedKeys } = mergeLegacyLocalStoragePatch(payload);
@@ -12200,7 +12705,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.9.8" : "0.0.0";
+var VERSION = true ? "4.0.0" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {