codexuse-cli 3.9.7 → 3.9.8

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,30 @@ 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 === "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 +2675,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);
@@ -3985,10 +4029,10 @@ function logError(...args) {
   console.error(...args);
 }
 function logInfo(...args) {
-  if (isTestEnv && !isMocked(console.warn)) {
+  if (isTestEnv && !isMocked(console.info)) {
     return;
   }
-  console.warn(...args);
+  console.info(...args);
 }
 
 // ../../packages/runtime-codex/src/codex/rpc.ts
@@ -5402,13 +5446,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;
@@ -8000,18 +8044,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 +8065,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,6 +8147,278 @@ function runCommand2(command, args, timeoutMs = COMMAND_TIMEOUT_MS) {
     });
   });
 }
+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 [];
+  }
+  return result.stdout.split(/\r?\n/).flatMap((line) => {
+    const match = line.match(
+      /^\s*(\d+)\s+(\d+)\s+([A-Z][a-z]{2}\s+[A-Z][a-z]{2}\s+\d+\s+\d+:\d+:\d+\s+\d{4})\s+(.+)$/
+    );
+    if (!match) {
+      return [];
+    }
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    const parsedStartedAt = Date.parse(match[3] ?? "");
+    const startedAt = Number.isFinite(parsedStartedAt) ? parsedStartedAt : null;
+    const args = match[4] ?? "";
+    if (!Number.isInteger(pid) || !Number.isInteger(ppid) || !args) {
+      return [];
+    }
+    return [{ pid, ppid, startedAt, args }];
+  });
+}
+function getMainExecutablePath(candidate) {
+  return import_node_path11.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
+}
+function isMainProcessRow(row, candidate) {
+  return row.args.includes(getMainExecutablePath(candidate));
+}
+function findAppServerPid(rows, mainPid) {
+  return rows.find(
+    (row) => row.ppid === mainPid && row.args.includes("/Contents/Resources/codex app-server")
+  )?.pid ?? null;
+}
+async function processMatchesProfileHome(pid, profileHome) {
+  const result = await runCommand2(
+    "/bin/ps",
+    ["eww", "-p", String(pid), "-o", "command="],
+    2e3
+  );
+  if (result.code !== 0) {
+    return false;
+  }
+  return result.stdout.includes(`CODEX_HOME=${profileHome}`) || result.stdout.includes(profileHome);
+}
+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;
+    }
+  }
+  return null;
+}
+async function describeUnmanagedProfileHint(appServerPid) {
+  if (!appServerPid) {
+    return {};
+  }
+  const result = await runCommand2(
+    "/bin/ps",
+    ["eww", "-p", String(appServerPid), "-o", "command="],
+    2e3
+  );
+  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)) {
@@ -8187,17 +8551,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 +8562,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 +8586,359 @@ 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 { status: "skipped", reason: "official-codex-app-not-found" };
-  }
-  const appIsRunning = mainPids.length > 0;
-  if (!appIsRunning && !options.launchIfNotRunning) {
-    await rememberRestartResult({
-      status: "skipped",
-      reason: "official-codex-app-not-running",
-      profileKey: options.currentProfileKey
-    });
-    return { status: "skipped", reason: "official-codex-app-not-running" };
+    return {
+      state: "not-found",
+      appPath: null,
+      bundleId: null,
+      version: null,
+      instances: [],
+      unmanaged: []
+    };
   }
-  if (options.source !== "manual") {
-    lastRestartStartedAt = Date.now();
+  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
+      )
+    );
   }
-  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
+  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)
     });
-    const exited = await waitForCodexExit(candidate, EXIT_WAIT_MS);
-    if (!exited) {
-      const remainingPids = await getRunningCodexPids(candidate);
-      logOfficialCodexRestart("error", "Official Codex pids remained after force kill.", {
+  }
+  return {
+    state: "found",
+    appPath: candidate.appPath,
+    bundleId: candidate.bundleId,
+    version: candidate.version,
+    instances: managed,
+    unmanaged
+  };
+}
+function launchOfficialCodexProfileInstance(options) {
+  return enqueueProfileAction(async () => {
+    if (process.platform !== "darwin") {
+      return {
+        status: "skipped",
+        profileName: options.profileName,
+        instance: null,
+        reason: "unsupported-platform"
+      };
+    }
+    const { candidate, mainPids } = await resolveCodexAppTarget();
+    if (!candidate) {
+      return {
+        status: "skipped",
+        profileName: options.profileName,
+        instance: null,
+        reason: "official-codex-app-not-found"
+      };
+    }
+    const existing = await readManagedInstance(options.profileName);
+    if (existing) {
+      const rows = await readProcessRows();
+      const runtime = await resolveInstanceRuntimeState({ instance: existing, candidate, rows });
+      if (runtime.running) {
+        const verified = {
+          ...existing,
+          profileHome: existing.profileHome ?? options.profileHome,
+          appServerPid: runtime.appServerPid,
+          lastVerifiedAt: Date.now(),
+          lastStatus: "already-running",
+          lastError: null
+        };
+        await patchManagedInstance(verified);
+        return {
+          status: "already-running",
+          profileName: options.profileName,
+          instance: managedInstanceToPayload(
+            verified,
+            true,
+            runtime.appServerPid,
+            runtime.startedAt
+          ),
+          reason: null
+        };
+      }
+    }
+    const launch = await openCodexWithProfileHome(
+      candidate,
+      options.profileHome,
+      options.profileName,
+      new Set(mainPids)
+    );
+    if (!launch.opened) {
+      const failed = {
+        profileName: options.profileName,
+        profileKey: options.profileKey,
+        profileHome: options.profileHome,
         appPath: candidate.appPath,
         bundleId: candidate.bundleId,
-        source: options.source,
-        remainingPids
-      });
+        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,
-        reason: "force-quit-timeout",
-        phase: "quit"
+        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;
     }
-    logOfficialCodexRestart("info", "Official Codex exited after force kill.", {
-      appPath: candidate.appPath,
-      bundleId: candidate.bundleId,
-      source: options.source
-    });
-  }
-  const opened = await openCodex(candidate);
-  if (!opened) {
-    const failed = {
-      status: "failed",
+    const now = Date.now();
+    const instance = {
+      profileName: options.profileName,
+      profileKey: options.profileKey,
+      profileHome: options.profileHome,
       appPath: candidate.appPath,
       bundleId: candidate.bundleId,
-      reason: "open-failed",
-      phase: "launch"
+      pid: launchedPid,
+      appServerPid,
+      launchedAt: now,
+      lastVerifiedAt: now,
+      lastStatus: "started",
+      lastError: null
     };
-    await rememberRestartResult({
-      status: failed.status,
-      reason: failed.reason,
-      profileKey: options.currentProfileKey
-    });
-    return failed;
-  }
-  const launchedPid = await waitForCodexLaunch(candidate);
-  if (launchedPid === null) {
-    logOfficialCodexRestart("error", "Official Codex launch was not verified.", {
-      appPath: candidate.appPath,
-      bundleId: candidate.bundleId,
-      source: options.source
-    });
-    const failed = {
-      status: "failed",
-      appPath: candidate.appPath,
-      bundleId: candidate.bundleId,
-      reason: "launch-timeout",
-      phase: "launch"
+    await patchManagedInstance(instance);
+    return {
+      status: "started",
+      profileName: options.profileName,
+      instance: managedInstanceToPayload(instance, true, appServerPid),
+      reason: null
     };
-    await rememberRestartResult({
-      status: failed.status,
-      reason: failed.reason,
-      profileKey: options.currentProfileKey
-    });
-    return failed;
-  }
-  const status = appIsRunning ? "restarted" : "started";
-  logOfficialCodexRestart("info", "Official Codex launch verified.", {
-    appPath: candidate.appPath,
-    bundleId: candidate.bundleId,
-    source: options.source,
-    status,
-    pid: launchedPid
   });
-  await rememberRestartResult({
-    status,
-    profileKey: options.currentProfileKey,
-    pid: launchedPid
+}
+function stopOfficialCodexProfileInstance(profileName) {
+  return enqueueProfileAction(async () => {
+    const existing = await readManagedInstance(profileName);
+    if (!existing) {
+      return {
+        status: "not-running",
+        profileName,
+        instance: null,
+        reason: "not-managed"
+      };
+    }
+    const { candidate } = await resolveCodexAppTarget();
+    if (!candidate) {
+      const stopped2 = {
+        ...existing,
+        pid: null,
+        appServerPid: null,
+        lastVerifiedAt: Date.now(),
+        lastStatus: "not-running",
+        lastError: "official-codex-app-not-found"
+      };
+      await patchManagedInstance(stopped2);
+      return {
+        status: "not-running",
+        profileName,
+        instance: managedInstanceToPayload(stopped2, false),
+        reason: "official-codex-app-not-found"
+      };
+    }
+    const rows = await readProcessRows();
+    const runtime = await resolveInstanceRuntimeState({ instance: existing, candidate, rows });
+    if (!runtime.running || !existing.pid) {
+      const stopped2 = {
+        ...existing,
+        pid: null,
+        appServerPid: null,
+        lastVerifiedAt: Date.now(),
+        lastStatus: "not-running",
+        lastError: null
+      };
+      await patchManagedInstance(stopped2);
+      return {
+        status: "not-running",
+        profileName,
+        instance: managedInstanceToPayload(stopped2, false),
+        reason: null
+      };
+    }
+    const tree = [existing.pid, ...getDescendantPids(existing.pid, rows)].filter((pid, index, all) => all.indexOf(pid) === index).sort((a, b) => b - a);
+    await signalPids(tree, "SIGTERM");
+    const exited = await waitForMainPidExit(existing.pid, 5e3);
+    if (!exited) {
+      await signalPids(tree, "SIGKILL");
+      await waitForMainPidExit(existing.pid, EXIT_WAIT_MS);
+    }
+    const stillRunning = (await readProcessRows()).some((row) => row.pid === existing.pid);
+    const stopped = {
+      ...existing,
+      pid: stillRunning ? existing.pid : null,
+      appServerPid: stillRunning ? runtime.appServerPid : null,
+      lastVerifiedAt: Date.now(),
+      lastStatus: stillRunning ? "failed" : "stopped",
+      lastError: stillRunning ? "stop-timeout" : null
+    };
+    await patchManagedInstance(stopped);
+    return {
+      status: stillRunning ? "failed" : "stopped",
+      profileName,
+      instance: managedInstanceToPayload(
+        stopped,
+        stillRunning,
+        stopped.appServerPid,
+        runtime.startedAt
+      ),
+      reason: stillRunning ? "stop-timeout" : null
+    };
   });
-  return {
-    status,
-    appPath: candidate.appPath,
-    bundleId: candidate.bundleId,
-    pid: launchedPid
-  };
 }
-function recordOfficialCodexProfileSwitch(profileKey) {
-  return rememberProfileSwitch(profileKey);
+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
+    };
+  });
 }
-function restartOfficialCodexApp(options = {}) {
-  if (restartPromise) {
-    return restartPromise;
+async function restartOfficialCodexProfileInstance(options) {
+  const stopped = await stopOfficialCodexProfileInstance(options.profileName);
+  if (stopped.status === "failed") {
+    return stopped;
   }
-  restartPromise = restartOfficialCodexAppOnce({
-    source: options.source ?? "manual",
-    currentProfileKey: options.currentProfileKey ?? null,
-    launchIfNotRunning: options.launchIfNotRunning ?? (options.source ?? "manual") === "manual"
-  }).finally(() => {
-    restartPromise = null;
-  });
-  return restartPromise;
+  const launched = await launchOfficialCodexProfileInstance(options);
+  return {
+    ...launched,
+    status: launched.status === "started" ? "restarted" : launched.status
+  };
 }
 
 // src/commands/profile.ts
@@ -8852,33 +9390,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 +9709,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 +9825,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) {
@@ -11503,7 +12200,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.9.7" : "0.0.0";
+var VERSION = true ? "3.9.8" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {