codexuse-cli 3.9.7 → 3.9.9

package/dist/index.js

@@ -2478,7 +2478,9 @@ function createDefaultAppState() {
       lastObservedPid: null,
       lastRestartStatus: null,
       lastRestartReason: null,
-      instancesByProfileName: {}
+      activity: [],
+      instancesByProfileName: {},
+      pendingRestartDebt: null
     },
     app: {
       lastAppVersion: null,
@@ -2582,6 +2584,9 @@ function asString(value) {
 function asNumberOrNull(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
+function asBooleanOrNull(value) {
+  return typeof value === "boolean" ? value : null;
+}
 function normalizeAppState(raw) {
   const defaults = createDefaultAppState();
   if (!isRecord2(raw)) {
@@ -2616,6 +2621,32 @@ function normalizeAppState(raw) {
   merged.officialCodex.lastRestartReason = asString(
     merged.officialCodex.lastRestartReason
   );
+  merged.officialCodex.activity = Array.isArray(merged.officialCodex.activity) ? merged.officialCodex.activity.filter((entry) => isRecord2(entry)).map((entry) => ({
+    id: asString(entry.id) ?? "",
+    at: asString(entry.at) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    kind: entry.kind === "auto-roll-eval" || entry.kind === "profile-switch" || entry.kind === "auth-verified" || entry.kind === "official-codex-restart" || entry.kind === "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),
+    profileName: asString(entry.profileName),
+    sourceProfileName: asString(entry.sourceProfileName),
+    targetProfileName: asString(entry.targetProfileName),
+    remainingPercent: asNumberOrNull(entry.remainingPercent),
+    threshold: asNumberOrNull(entry.threshold),
+    snapshotAgeMs: asNumberOrNull(entry.snapshotAgeMs),
+    snapshotSource: asString(entry.snapshotSource),
+    phase: asString(entry.phase),
+    pid: asNumberOrNull(entry.pid),
+    profileKeyHash: asString(entry.profileKeyHash),
+    switchVerified: asBooleanOrNull(entry.switchVerified),
+    restartRequested: asBooleanOrNull(entry.restartRequested),
+    restartResult: asString(entry.restartResult),
+    observedProfileName: asString(entry.observedProfileName),
+    observedProfileKeyHash: asString(entry.observedProfileKeyHash),
+    observedProfileMatchSource: asString(
+      entry.observedProfileMatchSource
+    )
+  })).filter((entry) => entry.id && entry.at).slice(-50) : [];
   if (!isRecord2(merged.officialCodex.instancesByProfileName)) {
     merged.officialCodex.instancesByProfileName = {};
   } else {
@@ -2646,6 +2677,21 @@ function normalizeAppState(raw) {
     }
     merged.officialCodex.instancesByProfileName = nextInstances;
   }
+  if (isRecord2(merged.officialCodex.pendingRestartDebt)) {
+    const debt = merged.officialCodex.pendingRestartDebt;
+    const targetProfileName = asString(debt.targetProfileName);
+    merged.officialCodex.pendingRestartDebt = targetProfileName ? {
+      targetProfileName,
+      targetProfileKey: asString(debt.targetProfileKey),
+      sourceProfileName: asString(debt.sourceProfileName),
+      sourceProfileKey: asString(debt.sourceProfileKey),
+      decisionId: asString(debt.decisionId),
+      attempts: asNumberOrNull(debt.attempts) ?? 0,
+      lastReason: asString(debt.lastReason)
+    } : null;
+  } else {
+    merged.officialCodex.pendingRestartDebt = null;
+  }
   merged.app.lastAppVersion = asString(merged.app.lastAppVersion);
   merged.app.pendingUpdateVersion = asString(merged.app.pendingUpdateVersion);
   merged.app.lastProfileName = asString(merged.app.lastProfileName);
@@ -2723,7 +2769,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;
   }
@@ -2731,13 +2779,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)) {
@@ -2766,26 +2816,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") {
@@ -2795,17 +2849,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;
   }
@@ -2824,14 +2882,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]];
-      })
+      )
     );
   }
   {
@@ -2898,7 +2958,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") {
@@ -2969,10 +3031,18 @@ async function readLegacyAppStateFromDisk() {
   }
 }
 async function readAppStateFromStorage() {
-  return readDocument(resolveStorageDbPath(), APP_STATE_DOCUMENT, normalizeAppState);
+  return readDocument(
+    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)
+  );
 }
 async function ensureInitialized() {
   if (appStateCache) {
@@ -3985,16 +4055,133 @@ function logError(...args) {
   console.error(...args);
 }
 function logInfo(...args) {
-  if (isTestEnv && !isMocked(console.warn)) {
+  if (isTestEnv && !isMocked(console.info)) {
     return;
   }
-  console.warn(...args);
+  console.info(...args);
 }
 
 // ../../packages/runtime-codex/src/codex/rpc.ts
 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;
@@ -4045,8 +4232,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;
   }
@@ -4097,10 +4293,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);
@@ -4250,7 +4449,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);
@@ -4271,11 +4474,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 {
@@ -5402,13 +5775,13 @@ var ProfileManager = class {
     const existingIdentity = this.resolveProfileIdentityFromData(profileName, existing, existingMetadata);
     const nextIdentity = this.resolveProfileIdentityFromData(profileName, normalized, metadata);
     if (existingIdentity && nextIdentity && existingIdentity !== nextIdentity) {
-      logWarn(
+      logInfo(
         `Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different OpenAI identity.`
       );
       return;
     }
     if (this.normalizeWorkspaceId(existing.workspace_id) !== this.normalizeWorkspaceId(normalized.workspace_id)) {
-      logWarn(
+      logInfo(
         `Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different workspace.`
       );
       return;
@@ -5824,6 +6197,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
    */
@@ -6276,7 +6668,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;
   }
@@ -6287,7 +6679,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;
   }
@@ -6299,7 +6691,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;
     }
@@ -6309,7 +6701,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) {
@@ -6343,7 +6735,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;
@@ -6459,8 +6851,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;
@@ -6476,7 +6868,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) {
@@ -6486,16 +6878,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)
   };
 }
@@ -6517,7 +6909,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;
     }
@@ -6532,7 +6924,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) {
@@ -6542,25 +6934,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) {
@@ -6576,8 +6968,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;
@@ -7252,7 +7644,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":
@@ -8000,18 +8392,17 @@ async function assertProfileCreationAllowed(profileManager) {
 
 // ../../packages/runtime-codex/src/codex/officialAppRestart.ts
 var import_node_child_process7 = require("child_process");
+var import_node_crypto6 = require("crypto");
 var import_node_fs8 = require("fs");
 var import_node_os5 = require("os");
 var import_node_path11 = __toESM(require("path"), 1);
-var RESTART_COOLDOWN_MS = 6e4;
 var COMMAND_TIMEOUT_MS = 3e3;
 var EXIT_WAIT_MS = 1e4;
 var LAUNCH_WAIT_MS = 15e3;
 var POLL_INTERVAL_MS = 250;
 var APP_DISCOVERY_CACHE_TTL_MS = 6e4;
 var APP_DISCOVERY_MISS_CACHE_TTL_MS = 5e3;
-var restartPromise = null;
-var lastRestartStartedAt = 0;
+var OFFICIAL_CODEX_ACTIVITY_LIMIT = 50;
 var profileActionLock = Promise.resolve();
 var appDiscoveryCache = null;
 function logOfficialCodexRestart(level, message, context) {
@@ -8022,6 +8413,55 @@ function logOfficialCodexRestart(level, message, context) {
   }
   logger(`[official-codex-restart] ${message}`);
 }
+function hashProfileKey(profileKey) {
+  if (!profileKey) {
+    return null;
+  }
+  return (0, import_node_crypto6.createHash)("sha256").update(profileKey).digest("hex").slice(0, 12);
+}
+async function recordOfficialCodexActivity(input) {
+  const now = /* @__PURE__ */ new Date();
+  const entry = {
+    id: `${now.getTime().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    at: now.toISOString(),
+    kind: input.kind,
+    status: input.status,
+    reason: input.reason ?? null,
+    decisionId: input.decisionId ?? null,
+    profileName: input.profileName ?? null,
+    sourceProfileName: input.sourceProfileName ?? null,
+    targetProfileName: input.targetProfileName ?? null,
+    remainingPercent: input.remainingPercent ?? null,
+    threshold: input.threshold ?? null,
+    snapshotAgeMs: input.snapshotAgeMs ?? null,
+    snapshotSource: input.snapshotSource ?? null,
+    phase: input.phase ?? null,
+    pid: input.pid ?? null,
+    profileKeyHash: input.profileKeyHash ?? hashProfileKey(input.profileKey),
+    switchVerified: input.switchVerified ?? null,
+    restartRequested: input.restartRequested ?? null,
+    restartResult: input.restartResult ?? null,
+    observedProfileName: input.observedProfileName ?? null,
+    observedProfileKeyHash: input.observedProfileKeyHash ?? hashProfileKey(input.observedProfileKey),
+    observedProfileMatchSource: input.observedProfileMatchSource ?? null
+  };
+  try {
+    await updateAppState((state) => ({
+      officialCodex: {
+        activity: [...state.officialCodex.activity, entry].slice(
+          -OFFICIAL_CODEX_ACTIVITY_LIMIT
+        )
+      }
+    }));
+  } catch (error) {
+    logOfficialCodexRestart("warn", "Failed to record official Codex activity.", {
+      kind: entry.kind,
+      status: entry.status,
+      profileKeyHash: entry.profileKeyHash,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
 function runCommand2(command, args, timeoutMs = COMMAND_TIMEOUT_MS) {
   return new Promise((resolve) => {
     const child = (0, import_node_child_process7.spawn)(command, args, {
@@ -8055,44 +8495,316 @@ function runCommand2(command, args, timeoutMs = COMMAND_TIMEOUT_MS) {
     });
   });
 }
-async function readBundleString(appPath, key) {
-  const plistPath = import_node_path11.default.join(appPath, "Contents", "Info.plist");
-  if (!(0, import_node_fs8.existsSync)(plistPath)) {
-    return null;
+function enqueueProfileAction(work) {
+  const run = profileActionLock.then(work, work);
+  profileActionLock = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+async function readProcessRows() {
+  const result = await runCommand2(
+    "/bin/ps",
+    ["-axo", "pid=,ppid=,lstart=,args="],
+    2e3
+  );
+  if (result.code !== 0) {
+    return [];
   }
-  const result = await runCommand2("/usr/bin/plutil", [
-    "-extract",
-    key,
-    "raw",
-    "-o",
-    "-",
-    plistPath
-  ]);
+  return result.stdout.split(/\r?\n/).flatMap((line) => {
+    const match = line.match(
+      /^\s*(\d+)\s+(\d+)\s+([A-Z][a-z]{2}\s+[A-Z][a-z]{2}\s+\d+\s+\d+:\d+:\d+\s+\d{4})\s+(.+)$/
+    );
+    if (!match) {
+      return [];
+    }
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    const parsedStartedAt = Date.parse(match[3] ?? "");
+    const startedAt = Number.isFinite(parsedStartedAt) ? parsedStartedAt : null;
+    const args = match[4] ?? "";
+    if (!Number.isInteger(pid) || !Number.isInteger(ppid) || !args) {
+      return [];
+    }
+    return [{ pid, ppid, startedAt, args }];
+  });
+}
+function getMainExecutablePath(candidate) {
+  return import_node_path11.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
+}
+function isMainProcessRow(row, candidate) {
+  return row.args.includes(getMainExecutablePath(candidate));
+}
+function findAppServerPid(rows, mainPid) {
+  return rows.find(
+    (row) => row.ppid === mainPid && row.args.includes("/Contents/Resources/codex app-server")
+  )?.pid ?? null;
+}
+async function processMatchesProfileHome(pid, profileHome) {
+  const result = await runCommand2(
+    "/bin/ps",
+    ["eww", "-p", String(pid), "-o", "command="],
+    2e3
+  );
   if (result.code !== 0) {
-    return null;
+    return false;
   }
-  const bundleId = result.stdout.trim();
-  return bundleId.length > 0 ? bundleId : null;
+  return result.stdout.includes(`CODEX_HOME=${profileHome}`) || result.stdout.includes(profileHome);
 }
-async function discoverCodexAppCandidates() {
-  const now = Date.now();
-  const envPath = process.env.CODEXUSE_OFFICIAL_CODEX_APP_PATH?.trim() || null;
-  if (appDiscoveryCache && appDiscoveryCache.envPath === envPath && appDiscoveryCache.expiresAt > now) {
-    return appDiscoveryCache.candidates;
+async function findAppServerPidForProfile(rows, mainPid, profileHome) {
+  const candidates = rows.filter(
+    (row) => row.ppid === mainPid && row.args.includes("/Contents/Resources/codex app-server")
+  );
+  for (const row of candidates) {
+    if (row.args.includes(profileHome) || await processMatchesProfileHome(row.pid, profileHome)) {
+      return row.pid;
+    }
   }
-  const rawPaths = /* @__PURE__ */ new Set();
-  if (envPath) {
-    rawPaths.add(envPath);
+  return null;
+}
+async function describeUnmanagedProfileHint(appServerPid) {
+  if (!appServerPid) {
+    return {};
   }
-  rawPaths.add("/Applications/Codex.app");
-  rawPaths.add(import_node_path11.default.join((0, import_node_os5.homedir)(), "Applications", "Codex.app"));
-  const mdfind = await runCommand2(
-    "/usr/bin/mdfind",
-    ["kMDItemFSName == 'Codex.app'"],
-    1500
+  const result = await runCommand2(
+    "/bin/ps",
+    ["eww", "-p", String(appServerPid), "-o", "command="],
+    2e3
   );
-  if (mdfind.code === 0) {
-    for (const line of mdfind.stdout.split(/\r?\n/)) {
+  if (result.code !== 0) {
+    return {};
+  }
+  const telemetryMatch = result.stdout.match(
+    /CODEX_TELEMETRY_LABEL=codexuse-profile-([^\s]+)/
+  );
+  if (telemetryMatch?.[1]) {
+    const encodedProfileName = telemetryMatch[1];
+    let profileName = encodedProfileName;
+    try {
+      profileName = decodeURIComponent(encodedProfileName);
+    } catch {
+      profileName = encodedProfileName;
+    }
+    return {
+      profileName,
+      profileMatchSource: "telemetry-label"
+    };
+  }
+  const profileHomeMatch = result.stdout.match(/profile-homes\/([^\s]+)/);
+  if (profileHomeMatch?.[1]) {
+    return {
+      profileName: profileHomeMatch[1],
+      profileMatchSource: "profile-home"
+    };
+  }
+  return {};
+}
+function getDescendantPids(rootPid, rows) {
+  const descendants = [];
+  const queue = [rootPid];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    for (const row of rows) {
+      if (row.ppid !== current || seen.has(row.pid)) {
+        continue;
+      }
+      descendants.push(row.pid);
+      queue.push(row.pid);
+    }
+  }
+  return descendants;
+}
+async function waitForNewMainPid(candidate, previousPids) {
+  const deadline = Date.now() + LAUNCH_WAIT_MS;
+  while (Date.now() < deadline) {
+    const rows = await readProcessRows();
+    const pid = rows.find((row) => isMainProcessRow(row, candidate) && !previousPids.has(row.pid))?.pid ?? null;
+    if (pid !== null) {
+      return pid;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return null;
+}
+async function waitForMainPid(candidate, pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const rows = await readProcessRows();
+    if (rows.some((row) => row.pid === pid && isMainProcessRow(row, candidate))) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+async function waitForAppServerPid(mainPid, profileHome) {
+  const deadline = Date.now() + LAUNCH_WAIT_MS;
+  while (Date.now() < deadline) {
+    const pid = await findAppServerPidForProfile(
+      await readProcessRows(),
+      mainPid,
+      profileHome
+    );
+    if (pid !== null) {
+      return pid;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return null;
+}
+async function waitForMainPidExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const rows = await readProcessRows();
+    if (!rows.some((row) => row.pid === pid)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  return false;
+}
+function managedInstanceToPayload(instance, running, appServerPid = instance.appServerPid, startedAt = null) {
+  const runningStartedAt = startedAt ?? instance.launchedAt;
+  return {
+    profileName: instance.profileName,
+    profileKey: instance.profileKey,
+    appPath: instance.appPath,
+    bundleId: instance.bundleId,
+    pid: running ? instance.pid : null,
+    appServerPid: running ? appServerPid : null,
+    running,
+    startedAt: running ? toIso(runningStartedAt) : null,
+    uptimeMs: running && typeof runningStartedAt === "number" ? Math.max(0, Date.now() - runningStartedAt) : null,
+    launchedAt: toIso(instance.launchedAt),
+    lastVerifiedAt: toIso(instance.lastVerifiedAt),
+    lastStatus: instance.lastStatus,
+    lastError: instance.lastError
+  };
+}
+async function patchManagedInstance(instance) {
+  await patchAppState({
+    officialCodex: {
+      instancesByProfileName: {
+        [instance.profileName]: instance
+      }
+    }
+  });
+}
+async function readManagedInstance(profileName) {
+  const state = await getAppState();
+  return state.officialCodex.instancesByProfileName[profileName] ?? null;
+}
+async function resolveInstanceRuntimeState(args) {
+  const pid = args.instance.pid;
+  if (!pid) {
+    return { running: false, appServerPid: null, startedAt: null };
+  }
+  const mainRow = args.rows.find((row) => row.pid === pid);
+  if (!mainRow || !isMainProcessRow(mainRow, args.candidate)) {
+    return { running: false, appServerPid: null, startedAt: null };
+  }
+  const appServerPid = args.instance.profileHome ? await findAppServerPidForProfile(args.rows, pid, args.instance.profileHome) : findAppServerPid(args.rows, pid);
+  if (args.instance.profileHome && appServerPid === null) {
+    return { running: false, appServerPid: null, startedAt: null };
+  }
+  return {
+    running: true,
+    appServerPid,
+    startedAt: mainRow.startedAt
+  };
+}
+async function openCodexWithProfileHome(candidate, profileHome, profileName, previousPids) {
+  const executablePath = getMainExecutablePath(candidate);
+  if (!(0, import_node_fs8.existsSync)(executablePath)) {
+    return { opened: false, pid: null };
+  }
+  const telemetryLabel = `codexuse-profile-${encodeURIComponent(profileName)}`;
+  let child;
+  try {
+    child = (0, import_node_child_process7.spawn)(executablePath, [], {
+      detached: true,
+      env: {
+        ...process.env,
+        CODEX_HOME: profileHome,
+        CODEX_TELEMETRY_LABEL: telemetryLabel
+      },
+      stdio: "ignore"
+    });
+  } catch {
+    return { opened: false, pid: null };
+  }
+  const childPid = child.pid ?? null;
+  child.unref();
+  const spawnError = await new Promise((resolve) => {
+    let settled = false;
+    const settle = (failed) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(failed);
+    };
+    child.once("error", () => settle(true));
+    setTimeout(() => settle(false), POLL_INTERVAL_MS);
+  });
+  if (spawnError) {
+    return { opened: false, pid: null };
+  }
+  if (childPid !== null) {
+    const verified = await waitForMainPid(candidate, childPid, 2e3);
+    if (verified) {
+      return { opened: true, pid: childPid };
+    }
+  }
+  return {
+    opened: true,
+    pid: await waitForNewMainPid(candidate, previousPids)
+  };
+}
+async function readBundleString(appPath, key) {
+  const plistPath = import_node_path11.default.join(appPath, "Contents", "Info.plist");
+  if (!(0, import_node_fs8.existsSync)(plistPath)) {
+    return null;
+  }
+  const result = await runCommand2("/usr/bin/plutil", [
+    "-extract",
+    key,
+    "raw",
+    "-o",
+    "-",
+    plistPath
+  ]);
+  if (result.code !== 0) {
+    return null;
+  }
+  const bundleId = result.stdout.trim();
+  return bundleId.length > 0 ? bundleId : null;
+}
+async function discoverCodexAppCandidates() {
+  const now = Date.now();
+  const envPath = process.env.CODEXUSE_OFFICIAL_CODEX_APP_PATH?.trim() || null;
+  if (appDiscoveryCache && appDiscoveryCache.envPath === envPath && appDiscoveryCache.expiresAt > now) {
+    return appDiscoveryCache.candidates;
+  }
+  const rawPaths = /* @__PURE__ */ new Set();
+  if (envPath) {
+    rawPaths.add(envPath);
+  }
+  rawPaths.add("/Applications/Codex.app");
+  rawPaths.add(import_node_path11.default.join((0, import_node_os5.homedir)(), "Applications", "Codex.app"));
+  const mdfind = await runCommand2(
+    "/usr/bin/mdfind",
+    ["kMDItemFSName == 'Codex.app'"],
+    1500
+  );
+  if (mdfind.code === 0) {
+    for (const line of mdfind.stdout.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (trimmed.endsWith("/Codex.app")) {
         rawPaths.add(trimmed);
@@ -8187,17 +8899,6 @@ async function resolveCodexAppTarget() {
   ]);
   return { candidate: fallback, runningPids, mainPids };
 }
-async function waitForCodexExit(candidate, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const pids = await getRunningCodexPids(candidate);
-    if (pids.length === 0) {
-      return true;
-    }
-    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-  }
-  return false;
-}
 async function signalPids(pids, signal) {
   const signaled = [];
   for (const pid of pids) {
@@ -8209,25 +8910,8 @@ async function signalPids(pids, signal) {
   }
   return signaled;
 }
-async function openCodex(candidate) {
-  const byBundle = await runCommand2("/usr/bin/open", ["-b", candidate.bundleId]);
-  if (byBundle.code === 0) {
-    return true;
-  }
-  const byPath = await runCommand2("/usr/bin/open", [candidate.appPath]);
-  return byPath.code === 0;
-}
-async function waitForCodexLaunch(candidate) {
-  const deadline = Date.now() + LAUNCH_WAIT_MS;
-  while (Date.now() < deadline) {
-    const pids = await getRunningCodexMainPids(candidate);
-    const pid = pids[0] ?? null;
-    if (pid !== null) {
-      return pid;
-    }
-    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-  }
-  return null;
+function toIso(value) {
+  return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : null;
 }
 async function rememberProfileSwitch(profileKey) {
   await patchAppState({
@@ -8250,157 +8934,360 @@ async function rememberRestartResult(args) {
     }
   });
 }
-async function restartOfficialCodexAppOnce(options) {
+function recordOfficialCodexRestartResult(args) {
+  return rememberRestartResult(args);
+}
+function recordOfficialCodexProfileSwitch(profileKey) {
+  return rememberProfileSwitch(profileKey);
+}
+async function getOfficialCodexProfileInstances() {
   if (process.platform !== "darwin") {
-    await rememberRestartResult({ status: "skipped", reason: "unsupported-platform" });
-    return { status: "skipped", reason: "unsupported-platform" };
-  }
-  const now = Date.now();
-  if (options.source !== "manual" && lastRestartStartedAt > 0 && now - lastRestartStartedAt < RESTART_COOLDOWN_MS) {
-    await rememberRestartResult({
-      status: "skipped",
-      reason: "cooldown",
-      profileKey: options.currentProfileKey
-    });
-    return { status: "skipped", reason: "cooldown" };
+    return {
+      state: "unsupported",
+      appPath: null,
+      bundleId: null,
+      version: null,
+      instances: [],
+      unmanaged: []
+    };
   }
-  const { candidate, runningPids, mainPids } = await resolveCodexAppTarget();
+  const { candidate, mainPids } = await resolveCodexAppTarget();
   if (!candidate) {
-    await rememberRestartResult({
-      status: "skipped",
-      reason: "official-codex-app-not-found",
-      profileKey: options.currentProfileKey
+    return {
+      state: "not-found",
+      appPath: null,
+      bundleId: null,
+      version: null,
+      instances: [],
+      unmanaged: []
+    };
+  }
+  const [state, rows] = await Promise.all([getAppState(), readProcessRows()]);
+  const managed = [];
+  for (const instance of Object.values(state.officialCodex.instancesByProfileName)) {
+    const runtime = await resolveInstanceRuntimeState({ instance, candidate, rows });
+    managed.push(
+      managedInstanceToPayload(
+        instance,
+        runtime.running,
+        runtime.appServerPid,
+        runtime.startedAt
+      )
+    );
+  }
+  managed.sort((a, b) => a.profileName.localeCompare(b.profileName));
+  const managedPids = new Set(
+    managed.flatMap((entry) => entry.running && entry.pid ? [entry.pid] : [])
+  );
+  const unmanaged = [];
+  for (const pid of mainPids.filter((entry) => !managedPids.has(entry))) {
+    const appServerPid = findAppServerPid(rows, pid);
+    const startedAt = rows.find((row) => row.pid === pid)?.startedAt ?? null;
+    unmanaged.push({
+      pid,
+      appServerPid,
+      startedAt: toIso(startedAt),
+      uptimeMs: typeof startedAt === "number" ? Math.max(0, Date.now() - startedAt) : null,
+      ...await describeUnmanagedProfileHint(appServerPid)
     });
-    return { status: "skipped", reason: "official-codex-app-not-found" };
   }
-  const appIsRunning = mainPids.length > 0;
-  if (!appIsRunning && !options.launchIfNotRunning) {
-    await rememberRestartResult({
+  return {
+    state: "found",
+    appPath: candidate.appPath,
+    bundleId: candidate.bundleId,
+    version: candidate.version,
+    instances: managed,
+    unmanaged
+  };
+}
+function launchOfficialCodexProfileInstance(options) {
+  return enqueueProfileAction(() => launchOfficialCodexProfileInstanceOnce(options));
+}
+async function launchOfficialCodexProfileInstanceOnce(options) {
+  if (process.platform !== "darwin") {
+    return {
       status: "skipped",
-      reason: "official-codex-app-not-running",
-      profileKey: options.currentProfileKey
-    });
-    return { status: "skipped", reason: "official-codex-app-not-running" };
+      profileName: options.profileName,
+      instance: null,
+      reason: "unsupported-platform"
+    };
   }
-  if (options.source !== "manual") {
-    lastRestartStartedAt = Date.now();
+  const { candidate, mainPids } = await resolveCodexAppTarget();
+  if (!candidate) {
+    return {
+      status: "skipped",
+      profileName: options.profileName,
+      instance: null,
+      reason: "official-codex-app-not-found"
+    };
   }
-  if (appIsRunning) {
-    logOfficialCodexRestart("warn", "Force killing official Codex before relaunch.", {
-      appPath: candidate.appPath,
-      bundleId: candidate.bundleId,
-      source: options.source,
-      runningPids,
-      mainPids
-    });
-    const killedPids = await signalPids(runningPids, "SIGKILL");
-    logOfficialCodexRestart("warn", "Sent SIGKILL to official Codex pids.", {
-      appPath: candidate.appPath,
-      bundleId: candidate.bundleId,
-      source: options.source,
-      killedPids
-    });
-    const exited = await waitForCodexExit(candidate, EXIT_WAIT_MS);
-    if (!exited) {
-      const remainingPids = await getRunningCodexPids(candidate);
-      logOfficialCodexRestart("error", "Official Codex pids remained after force kill.", {
-        appPath: candidate.appPath,
-        bundleId: candidate.bundleId,
-        source: options.source,
-        remainingPids
-      });
-      const failed = {
-        status: "failed",
-        appPath: candidate.appPath,
-        bundleId: candidate.bundleId,
-        reason: "force-quit-timeout",
-        phase: "quit"
+  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
       };
-      await rememberRestartResult({
-        status: failed.status,
-        reason: failed.reason,
-        profileKey: options.currentProfileKey
-      });
-      return failed;
     }
-    logOfficialCodexRestart("info", "Official Codex exited after force kill.", {
-      appPath: candidate.appPath,
-      bundleId: candidate.bundleId,
-      source: options.source
-    });
   }
-  const opened = await openCodex(candidate);
-  if (!opened) {
+  const launch = await openCodexWithProfileHome(
+    candidate,
+    options.profileHome,
+    options.profileName,
+    new Set(mainPids)
+  );
+  if (!launch.opened) {
     const failed = {
-      status: "failed",
+      profileName: options.profileName,
+      profileKey: options.profileKey,
+      profileHome: options.profileHome,
       appPath: candidate.appPath,
       bundleId: candidate.bundleId,
-      reason: "open-failed",
-      phase: "launch"
+      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"
     };
-    await rememberRestartResult({
-      status: failed.status,
-      reason: failed.reason,
-      profileKey: options.currentProfileKey
-    });
-    return failed;
   }
-  const launchedPid = await waitForCodexLaunch(candidate);
+  const launchedPid = launch.pid;
   if (launchedPid === null) {
-    logOfficialCodexRestart("error", "Official Codex launch was not verified.", {
+    const failed = {
+      profileName: options.profileName,
+      profileKey: options.profileKey,
+      profileHome: options.profileHome,
       appPath: candidate.appPath,
       bundleId: candidate.bundleId,
-      source: options.source
-    });
-    const failed = {
+      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,
-      reason: "launch-timeout",
-      phase: "launch"
+      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"
     };
-    await rememberRestartResult({
-      status: failed.status,
-      reason: failed.reason,
-      profileKey: options.currentProfileKey
-    });
-    return failed;
   }
-  const status = appIsRunning ? "restarted" : "started";
-  logOfficialCodexRestart("info", "Official Codex launch verified.", {
+  const now = Date.now();
+  const instance = {
+    profileName: options.profileName,
+    profileKey: options.profileKey,
+    profileHome: options.profileHome,
     appPath: candidate.appPath,
     bundleId: candidate.bundleId,
-    source: options.source,
-    status,
-    pid: launchedPid
-  });
-  await rememberRestartResult({
-    status,
-    profileKey: options.currentProfileKey,
-    pid: launchedPid
-  });
+    pid: launchedPid,
+    appServerPid,
+    launchedAt: now,
+    lastVerifiedAt: now,
+    lastStatus: "started",
+    lastError: null
+  };
+  await patchManagedInstance(instance);
   return {
-    status,
-    appPath: candidate.appPath,
-    bundleId: candidate.bundleId,
-    pid: launchedPid
+    status: "started",
+    profileName: options.profileName,
+    instance: managedInstanceToPayload(instance, true, appServerPid),
+    reason: null
   };
 }
-function recordOfficialCodexProfileSwitch(profileKey) {
-  return rememberProfileSwitch(profileKey);
-}
-function restartOfficialCodexApp(options = {}) {
-  if (restartPromise) {
-    return restartPromise;
+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: 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
+    };
   }
-  restartPromise = restartOfficialCodexAppOnce({
-    source: options.source ?? "manual",
-    currentProfileKey: options.currentProfileKey ?? null,
-    launchIfNotRunning: options.launchIfNotRunning ?? (options.source ?? "manual") === "manual"
-  }).finally(() => {
-    restartPromise = null;
+  const tree = [existing.pid, ...getDescendantPids(existing.pid, rows)].filter((pid, index, all) => all.indexOf(pid) === index).sort((a, b) => b - a);
+  await signalPids(tree, "SIGTERM");
+  const exited = await waitForMainPidExit(existing.pid, 5e3);
+  if (!exited) {
+    await signalPids(tree, "SIGKILL");
+    await waitForMainPidExit(existing.pid, EXIT_WAIT_MS);
+  }
+  const stillRunning = (await readProcessRows()).some((row) => row.pid === existing.pid);
+  const stopped = {
+    ...existing,
+    pid: stillRunning ? existing.pid : null,
+    appServerPid: stillRunning ? runtime.appServerPid : null,
+    lastVerifiedAt: Date.now(),
+    lastStatus: stillRunning ? "failed" : "stopped",
+    lastError: stillRunning ? "stop-timeout" : null
+  };
+  await patchManagedInstance(stopped);
+  return {
+    status: stillRunning ? "failed" : "stopped",
+    profileName,
+    instance: managedInstanceToPayload(
+      stopped,
+      stillRunning,
+      stopped.appServerPid,
+      runtime.startedAt
+    ),
+    reason: stillRunning ? "stop-timeout" : null
+  };
+}
+function stopOfficialCodexObservedProfileInstance(profileName, pid, appServerPid) {
+  return enqueueProfileAction(async () => {
+    const { candidate } = await resolveCodexAppTarget();
+    if (!candidate) {
+      return {
+        status: "not-running",
+        profileName,
+        instance: null,
+        reason: "official-codex-app-not-found"
+      };
+    }
+    const rows = await readProcessRows();
+    const mainRow = rows.find((row) => row.pid === pid);
+    if (!mainRow || !isMainProcessRow(mainRow, candidate)) {
+      return {
+        status: "not-running",
+        profileName,
+        instance: null,
+        reason: null
+      };
+    }
+    const runtimeAppServerPid = findAppServerPid(rows, pid) ?? appServerPid;
+    const tree = [pid, ...getDescendantPids(pid, rows)].filter((entry, index, all) => all.indexOf(entry) === index).sort((a, b) => b - a);
+    await signalPids(tree, "SIGTERM");
+    const exited = await waitForMainPidExit(pid, 5e3);
+    if (!exited) {
+      await signalPids(tree, "SIGKILL");
+      await waitForMainPidExit(pid, EXIT_WAIT_MS);
+    }
+    const stillRunning = (await readProcessRows()).some((row) => row.pid === pid);
+    const instance = {
+      profileName,
+      profileKey: null,
+      appPath: candidate.appPath,
+      bundleId: candidate.bundleId,
+      pid: stillRunning ? pid : null,
+      appServerPid: stillRunning ? runtimeAppServerPid : null,
+      running: stillRunning,
+      startedAt: stillRunning ? toIso(mainRow.startedAt) : null,
+      uptimeMs: stillRunning && typeof mainRow.startedAt === "number" ? Math.max(0, Date.now() - mainRow.startedAt) : null,
+      launchedAt: null,
+      lastVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastStatus: stillRunning ? "failed" : "stopped",
+      lastError: stillRunning ? "stop-timeout" : null
+    };
+    return {
+      status: stillRunning ? "failed" : "stopped",
+      profileName,
+      instance,
+      reason: stillRunning ? "stop-timeout" : null
+    };
+  });
+}
+async function restartOfficialCodexProfileInstance(options) {
+  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
+    };
   });
-  return restartPromise;
 }
 
 // src/commands/profile.ts
@@ -8852,33 +9739,190 @@ async function rememberOfficialCodexSwitch(profileKey) {
     );
   }
 }
-function formatOfficialCodexRestart(result) {
+function formatOfficialCodexProfileAction(result) {
   if (result.status === "restarted") {
     return "Official Codex restarted.";
   }
   if (result.status === "started") {
     return "Official Codex started.";
   }
+  if (result.status === "already-running") {
+    return "Official Codex already running.";
+  }
   if (result.status === "failed") {
     return `Official Codex restart failed: ${result.reason}.`;
   }
-  if (result.status === "skipped") {
+  if (result.status === "skipped" || result.status === "not-running") {
     return `Official Codex restart skipped: ${result.reason}.`;
   }
   return "Official Codex restart status unknown.";
 }
+function findUnmanagedOfficialCodexRestartTarget(instances, profileName, profileKey) {
+  const restartable = instances.unmanaged.filter((instance) => instance.pid);
+  const matched = restartable.find((instance) => {
+    if (profileKey && instance.profileKey) {
+      return instance.profileKey === profileKey;
+    }
+    if (instance.profileKey) {
+      return false;
+    }
+    return instance.profileName === profileName;
+  }) ?? null;
+  if (matched) {
+    return { target: matched, ambiguous: false, unverified: false };
+  }
+  if (restartable.length > 1) {
+    return { target: null, ambiguous: true, unverified: false };
+  }
+  return { target: null, ambiguous: false, unverified: restartable.length === 1 };
+}
+async function restartUnmanagedOfficialCodexWindow(profileName, launchOptions, target) {
+  const stopped = await stopOfficialCodexObservedProfileInstance(
+    target.profileName ?? profileName,
+    target.pid,
+    target.appServerPid
+  );
+  if (stopped.status === "failed") {
+    return stopped;
+  }
+  const launched = await launchOfficialCodexProfileInstance(launchOptions);
+  return {
+    ...launched,
+    status: stopped.status === "stopped" && launched.status === "started" ? "restarted" : launched.status
+  };
+}
+async function recordCliOfficialCodexRestartResult(profileName, profileKey, action) {
+  const pid = action.status === "started" || action.status === "restarted" ? action.instance?.pid ?? null : null;
+  const status = action.status === "started" || action.status === "restarted" ? action.status : action.status === "failed" ? "failed" : "skipped";
+  const reason = action.status === "started" || action.status === "restarted" ? null : action.reason ?? action.status;
+  try {
+    await recordOfficialCodexRestartResult({
+      status,
+      reason,
+      profileKey,
+      pid
+    });
+    await recordOfficialCodexActivity({
+      kind: "official-codex-restart",
+      status,
+      reason,
+      targetProfileName: profileName,
+      profileKey,
+      phase: "cli",
+      pid,
+      restartRequested: true,
+      restartResult: status
+    });
+  } catch (error) {
+    console.warn(
+      `Could not record official Codex restart state: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function recordCliOfficialCodexRestartSkipped(profileName, profileKey, reason) {
+  await recordCliOfficialCodexRestartResult(profileName, profileKey, {
+    status: "skipped",
+    profileName,
+    instance: null,
+    reason
+  });
+}
 async function maybeRestartOfficialCodex(options) {
   if (!options.enabled) {
     return null;
   }
   try {
-    const result = await restartOfficialCodexApp({
-      source: options.source,
-      currentProfileKey: options.profileKey,
-      launchIfNotRunning: options.launchIfNotRunning
-    });
-    return formatOfficialCodexRestart(result);
+    const runtime = await options.manager.prepareProfileRuntime(options.profileName);
+    const launchOptions = {
+      profileName: options.profileName,
+      profileKey: options.profileKey,
+      profileHome: runtime.profileHome
+    };
+    const instances = await getOfficialCodexProfileInstances();
+    if (instances.state === "unsupported") {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "unsupported-platform"
+      );
+      return "Official Codex restart skipped: unsupported-platform.";
+    }
+    if (instances.state === "not-found") {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "official-codex-app-not-found"
+      );
+      return "Official Codex restart skipped: official-codex-app-not-found.";
+    }
+    const managedRunning = instances.instances.some(
+      (instance) => instance.profileName === options.profileName && instance.running
+    );
+    const unmanaged = findUnmanagedOfficialCodexRestartTarget(
+      instances,
+      options.profileName,
+      options.profileKey
+    );
+    if (unmanaged.target && !managedRunning) {
+      const action2 = await restartUnmanagedOfficialCodexWindow(
+        options.profileName,
+        launchOptions,
+        unmanaged.target
+      );
+      await recordCliOfficialCodexRestartResult(
+        options.profileName,
+        options.profileKey,
+        action2
+      );
+      return formatOfficialCodexProfileAction(action2);
+    }
+    if (unmanaged.ambiguous && !managedRunning) {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "ambiguous-official-codex-windows"
+      );
+      return "Official Codex restart skipped: ambiguous-official-codex-windows.";
+    }
+    if (unmanaged.unverified && !managedRunning) {
+      await recordCliOfficialCodexRestartSkipped(
+        options.profileName,
+        options.profileKey,
+        "unverified-official-codex-window"
+      );
+      return "Official Codex restart skipped: unverified-official-codex-window.";
+    }
+    if (options.launchIfNotRunning === false) {
+      if (!managedRunning) {
+        await recordCliOfficialCodexRestartSkipped(
+          options.profileName,
+          options.profileKey,
+          "official-codex-app-not-running"
+        );
+        return "Official Codex restart skipped: official-codex-app-not-running.";
+      }
+      const action2 = await restartOfficialCodexProfileInstance(launchOptions);
+      await recordCliOfficialCodexRestartResult(
+        options.profileName,
+        options.profileKey,
+        action2
+      );
+      return formatOfficialCodexProfileAction(action2);
+    }
+    const action = await restartOfficialCodexProfileInstance(launchOptions);
+    await recordCliOfficialCodexRestartResult(
+      options.profileName,
+      options.profileKey,
+      action
+    );
+    return formatOfficialCodexProfileAction(action);
   } catch (error) {
+    await recordCliOfficialCodexRestartResult(options.profileName, options.profileKey, {
+      status: "failed",
+      profileName: options.profileName,
+      instance: null,
+      reason: error instanceof Error ? error.message : "restart-threw"
+    });
     return `Official Codex restart failed: ${error instanceof Error ? error.message : String(error)}.`;
   }
 }
@@ -9014,8 +10058,9 @@ async function runAutoRollPass(manager, options) {
   const targetProfileKey = profileRateLimitKey(candidate.profile);
   await rememberOfficialCodexSwitch(targetProfileKey);
   const restartMessage = await maybeRestartOfficialCodex({
+    manager,
     enabled: options.restartOfficialCodex,
-    source: "auto-roll",
+    profileName: candidate.profile.name,
     profileKey: targetProfileKey,
     launchIfNotRunning: options.launchOfficialCodexWhenClosed === true
   });
@@ -9129,8 +10174,9 @@ async function handleProfileCommand(args, version) {
       console.log(`Switched to profile: ${name}`);
       await rememberOfficialCodexSwitch(targetProfileKey);
       const restartMessage = await maybeRestartOfficialCodex({
+        manager,
         enabled: restartOfficialCodex,
-        source: "manual",
+        profileName: name,
         profileKey: targetProfileKey
       });
       if (restartMessage) {
@@ -9244,7 +10290,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) {
@@ -9282,10 +10328,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;
@@ -9300,9 +10346,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,
@@ -9318,7 +10364,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,
@@ -9502,7 +10548,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) {
@@ -9567,16 +10613,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,
@@ -10362,15 +11408,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;
     }
@@ -10382,7 +11428,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,
@@ -10396,7 +11442,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,
@@ -10501,7 +11547,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.");
   }
@@ -10525,7 +11571,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({});
@@ -10778,10 +11824,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;
   }
@@ -10950,7 +11996,7 @@ function pickAutoRoll(raw) {
   }
 }
 function parseLegacyLicense(raw) {
-  if (!isRecord6(raw)) {
+  if (!isRecord7(raw)) {
     return {
       licenseKey: null,
       purchaseEmail: null,
@@ -10961,25 +12007,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 {
@@ -10993,31 +12039,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 ? {
@@ -11035,22 +12081,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 {
@@ -11090,21 +12136,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() {
@@ -11135,7 +12181,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 {};
   }
@@ -11167,7 +12213,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;
@@ -11186,15 +12232,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 ?? {},
@@ -11207,12 +12253,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;
     }
@@ -11435,7 +12481,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);
@@ -11503,7 +12549,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.9.7" : "0.0.0";
+var VERSION = true ? "3.9.9" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {