codexuse-cli 3.9.7 → 3.9.8

package/dist/server/index.mjs

@@ -58516,7 +58516,9 @@ function createDefaultAppState() {
 			lastObservedPid: null,
 			lastRestartStatus: null,
 			lastRestartReason: null,
-			instancesByProfileName: {}
+			activity: [],
+			instancesByProfileName: {},
+			pendingRestartDebt: null
 		},
 		app: {
 			lastAppVersion: null,
@@ -58612,6 +58614,9 @@ function asString$9(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 (!isRecord$7(raw)) return defaults;
@@ -58627,6 +58632,30 @@ function normalizeAppState(raw) {
 	merged.officialCodex.lastObservedPid = asNumberOrNull(merged.officialCodex.lastObservedPid);
 	merged.officialCodex.lastRestartStatus = asString$9(merged.officialCodex.lastRestartStatus);
 	merged.officialCodex.lastRestartReason = asString$9(merged.officialCodex.lastRestartReason);
+	merged.officialCodex.activity = Array.isArray(merged.officialCodex.activity) ? merged.officialCodex.activity.filter((entry) => isRecord$7(entry)).map((entry) => ({
+		id: asString$9(entry.id) ?? "",
+		at: asString$9(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$9(entry.status) ?? "unknown",
+		reason: asString$9(entry.reason),
+		decisionId: asString$9(entry.decisionId),
+		profileName: asString$9(entry.profileName),
+		sourceProfileName: asString$9(entry.sourceProfileName),
+		targetProfileName: asString$9(entry.targetProfileName),
+		remainingPercent: asNumberOrNull(entry.remainingPercent),
+		threshold: asNumberOrNull(entry.threshold),
+		snapshotAgeMs: asNumberOrNull(entry.snapshotAgeMs),
+		snapshotSource: asString$9(entry.snapshotSource),
+		phase: asString$9(entry.phase),
+		pid: asNumberOrNull(entry.pid),
+		profileKeyHash: asString$9(entry.profileKeyHash),
+		switchVerified: asBooleanOrNull(entry.switchVerified),
+		restartRequested: asBooleanOrNull(entry.restartRequested),
+		restartResult: asString$9(entry.restartResult),
+		observedProfileName: asString$9(entry.observedProfileName),
+		observedProfileKeyHash: asString$9(entry.observedProfileKeyHash),
+		observedProfileMatchSource: asString$9(entry.observedProfileMatchSource)
+	})).filter((entry) => entry.id && entry.at).slice(-50) : [];
 	if (!isRecord$7(merged.officialCodex.instancesByProfileName)) merged.officialCodex.instancesByProfileName = {};
 	else {
 		const nextInstances = {};
@@ -58650,6 +58679,19 @@ function normalizeAppState(raw) {
 		}
 		merged.officialCodex.instancesByProfileName = nextInstances;
 	}
+	if (isRecord$7(merged.officialCodex.pendingRestartDebt)) {
+		const debt = merged.officialCodex.pendingRestartDebt;
+		const targetProfileName = asString$9(debt.targetProfileName);
+		merged.officialCodex.pendingRestartDebt = targetProfileName ? {
+			targetProfileName,
+			targetProfileKey: asString$9(debt.targetProfileKey),
+			sourceProfileName: asString$9(debt.sourceProfileName),
+			sourceProfileKey: asString$9(debt.sourceProfileKey),
+			decisionId: asString$9(debt.decisionId),
+			attempts: asNumberOrNull(debt.attempts) ?? 0,
+			lastReason: asString$9(debt.lastReason)
+		} : null;
+	} else merged.officialCodex.pendingRestartDebt = null;
 	merged.app.lastAppVersion = asString$9(merged.app.lastAppVersion);
 	merged.app.pendingUpdateVersion = asString$9(merged.app.pendingUpdateVersion);
 	merged.app.lastProfileName = asString$9(merged.app.lastProfileName);
@@ -59964,8 +60006,8 @@ function logError(...args) {
 	console.error(...args);
 }
 function logInfo(...args) {
-	if (isTestEnv && !isMocked(console.warn)) return;
-	console.warn(...args);
+	if (isTestEnv && !isMocked(console.info)) return;
+	console.info(...args);
 }
 //#endregion
 //#region ../../packages/runtime-codex/src/codex/app-server.ts
@@ -74725,11 +74767,11 @@ var ProfileManager = class {
 		const existingIdentity = this.resolveProfileIdentityFromData(profileName, existing, existingMetadata);
 		const nextIdentity = this.resolveProfileIdentityFromData(profileName, normalized, metadata);
 		if (existingIdentity && nextIdentity && existingIdentity !== nextIdentity) {
-			logWarn(`Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different OpenAI identity.`);
+			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(`Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different workspace.`);
+			logInfo(`Skipped syncing tokens for profile '${profileName}' because Codex auth switched to a different workspace.`);
 			return;
 		}
 		if (!this.hasTokenChanges(existing, normalized)) return;
@@ -82274,15 +82316,13 @@ function createTelegramBridge(options) {
 }
 //#endregion
 //#region ../../packages/runtime-codex/src/codex/officialAppRestart.ts
-const RESTART_COOLDOWN_MS = 6e4;
 const COMMAND_TIMEOUT_MS = 3e3;
 const EXIT_WAIT_MS = 1e4;
 const LAUNCH_WAIT_MS = 15e3;
 const POLL_INTERVAL_MS = 250;
 const APP_DISCOVERY_CACHE_TTL_MS = 6e4;
 const APP_DISCOVERY_MISS_CACHE_TTL_MS = 5e3;
-let restartPromise = null;
-let lastRestartStartedAt = 0;
+const OFFICIAL_CODEX_ACTIVITY_LIMIT = 50;
 let profileActionLock = Promise.resolve();
 let appDiscoveryCache = null;
 function logOfficialCodexRestart(level, message, context) {
@@ -82293,6 +82333,47 @@ function logOfficialCodexRestart(level, message, context) {
 	}
 	logger(`[official-codex-restart] ${message}`);
 }
+function hashProfileKey(profileKey) {
+	if (!profileKey) return null;
+	return 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 runCommand(command, args, timeoutMs = COMMAND_TIMEOUT_MS) {
 	return new Promise((resolve) => {
 		const child = spawn(command, args, { stdio: [
@@ -82670,14 +82751,6 @@ async function resolveCodexAppTarget() {
 		mainPids
 	};
 }
-async function waitForCodexExit(candidate, timeoutMs) {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if ((await getRunningCodexPids(candidate)).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) try {
@@ -82686,19 +82759,6 @@ async function signalPids(pids, signal) {
 	} catch {}
 	return signaled;
 }
-async function openCodex(candidate) {
-	if ((await runCommand("/usr/bin/open", ["-b", candidate.bundleId])).code === 0) return true;
-	return (await runCommand("/usr/bin/open", [candidate.appPath])).code === 0;
-}
-async function waitForCodexLaunch(candidate) {
-	const deadline = Date.now() + LAUNCH_WAIT_MS;
-	while (Date.now() < deadline) {
-		const pid = (await getRunningCodexMainPids(candidate))[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;
 }
@@ -82719,152 +82779,15 @@ async function rememberRestartResult(args) {
 		lastRestartReason: args.reason ?? null
 	} });
 }
-async function restartOfficialCodexAppOnce(options) {
-	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"
-		};
-	}
-	const { candidate, runningPids, 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"
-		};
-	}
-	if (options.source !== "manual") lastRestartStartedAt = Date.now();
-	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
-		});
-		if (!await waitForCodexExit(candidate, EXIT_WAIT_MS)) {
-			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"
-			};
-			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
-		});
-	}
-	if (!await openCodex(candidate)) {
-		const failed = {
-			status: "failed",
-			appPath: candidate.appPath,
-			bundleId: candidate.bundleId,
-			reason: "open-failed",
-			phase: "launch"
-		};
-		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 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
-	});
-	return {
-		status,
-		appPath: candidate.appPath,
-		bundleId: candidate.bundleId,
-		pid: launchedPid
-	};
+async function recordOfficialCodexProfileObservation(profileKey, pid) {
+	if (!profileKey || !pid) return;
+	await patchAppState({ officialCodex: {
+		lastVerifiedLaunchProfileKey: profileKey,
+		lastObservedPid: pid
+	} });
+}
+function recordOfficialCodexRestartResult(args) {
+	return rememberRestartResult(args);
 }
 async function getOfficialCodexSyncStatus(currentProfileKey) {
 	const stored = (await getAppState()).officialCodex;
@@ -82873,7 +82796,8 @@ async function getOfficialCodexSyncStatus(currentProfileKey) {
 		lastProfileSwitchAt: toIso(stored.lastProfileSwitchAt),
 		lastVerifiedLaunchAt: toIso(stored.lastVerifiedLaunchAt),
 		lastRestartStatus: stored.lastRestartStatus,
-		lastRestartReason: stored.lastRestartReason
+		lastRestartReason: stored.lastRestartReason,
+		activity: stored.activity
 	};
 	if (process.platform !== "darwin") return {
 		...base,
@@ -82894,10 +82818,12 @@ async function getOfficialCodexSyncStatus(currentProfileKey) {
 	const lastSwitchAt = stored.lastProfileSwitchAt;
 	const lastLaunchAt = stored.lastVerifiedLaunchAt;
 	const lastLaunchProfileKey = stored.lastVerifiedLaunchProfileKey;
-	const stale = Boolean(currentProfileKey && lastSwitchAt && (!lastLaunchAt || lastLaunchAt < lastSwitchAt || lastLaunchProfileKey !== currentProfileKey));
+	const lastObservedPid = stored.lastObservedPid;
+	const observedSynced = Boolean(currentProfileKey && lastLaunchProfileKey === currentProfileKey && lastObservedPid && mainPids.includes(lastObservedPid));
+	const stale = Boolean(!observedSynced && currentProfileKey && lastSwitchAt && (!lastLaunchAt || lastLaunchAt < lastSwitchAt || lastLaunchProfileKey !== currentProfileKey));
 	return {
 		...base,
-		state: stale ? "stale" : currentProfileKey && lastLaunchProfileKey === currentProfileKey ? "synced" : "unknown",
+		state: observedSynced ? "synced" : stale ? "stale" : "unknown",
 		appPath: candidate.appPath,
 		bundleId: candidate.bundleId,
 		runningPids: mainPids
@@ -83306,17 +83232,6 @@ async function restartOfficialCodexProfileInstance(options) {
 		status: launched.status === "started" ? "restarted" : launched.status
 	};
 }
-function restartOfficialCodexApp(options = {}) {
-	if (restartPromise) return restartPromise;
-	restartPromise = restartOfficialCodexAppOnce({
-		source: options.source ?? "manual",
-		currentProfileKey: options.currentProfileKey ?? null,
-		launchIfNotRunning: options.launchIfNotRunning ?? (options.source ?? "manual") === "manual"
-	}).finally(() => {
-		restartPromise = null;
-	});
-	return restartPromise;
-}
 //#endregion
 //#region src/wsServer.ts
 /**
@@ -84170,6 +84085,57 @@ const createServer = fn(function* () {
 	};
 	const lowRemainingNotifications = /* @__PURE__ */ new Map();
 	const finitePercent = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.min(100, value)) : null;
+	const AUTO_ROLL_SNAPSHOT_MAX_AGE_MS = 3 * 6e4;
+	const AUTO_ROLL_WATCHDOG_INTERVAL_MS = 6e4;
+	const AUTO_ROLL_WATCHDOG_ACTIVITY_TTL_MS = 10 * 6e4;
+	const parseRateLimitTimestamp = (value) => {
+		if (!value) return null;
+		const parsed = Date.parse(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	};
+	const createAutoRollDecisionId = () => `ar-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+	const buildSnapshotDiagnostic = (cached, profileSnapshot, fallbackSource = "none") => {
+		const candidates = [{
+			snapshot: cached ?? null,
+			source: "cache",
+			updatedAt: parseRateLimitTimestamp(cached?.lastUpdated)
+		}, {
+			snapshot: profileSnapshot ?? null,
+			source: "profile",
+			updatedAt: parseRateLimitTimestamp(profileSnapshot?.lastUpdated)
+		}].filter((entry) => Boolean(entry.snapshot));
+		candidates.sort((a, b) => (b.updatedAt ?? -Infinity) - (a.updatedAt ?? -Infinity));
+		const selected = candidates[0] ?? null;
+		const snapshot = selected?.snapshot ?? null;
+		const source = selected?.source ?? fallbackSource;
+		const updatedAt = parseRateLimitTimestamp(snapshot?.lastUpdated);
+		return {
+			snapshot,
+			source,
+			ageMs: updatedAt === null ? null : Math.max(0, Date.now() - updatedAt)
+		};
+	};
+	const freshAutoRollSnapshot = (snapshot) => {
+		if (!snapshot) return null;
+		const updatedAt = parseRateLimitTimestamp(snapshot.lastUpdated);
+		if (updatedAt === null || Date.now() - updatedAt >= AUTO_ROLL_SNAPSHOT_MAX_AGE_MS) return null;
+		const now = Date.now();
+		const keepWindow = (window) => {
+			if (!window || finitePercent(window.usedPercent) === null) return window;
+			const resetsAt = parseRateLimitTimestamp(window.resetsAt);
+			if (resetsAt !== null && resetsAt <= now) return;
+			return window;
+		};
+		return {
+			...snapshot,
+			primary: keepWindow(snapshot.primary),
+			secondary: keepWindow(snapshot.secondary)
+		};
+	};
+	const isSnapshotStaleForAutoRollWatchdog = (snapshot) => {
+		const updatedAt = parseRateLimitTimestamp(snapshot?.lastUpdated);
+		return updatedAt === null || Date.now() - updatedAt >= AUTO_ROLL_SNAPSHOT_MAX_AGE_MS;
+	};
 	const formatLowRemainingPercent = (value) => {
 		const rounded = Math.round(value * 10) / 10;
 		return (Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1)).replace(/\.0$/, "");
@@ -84221,6 +84187,17 @@ const createServer = fn(function* () {
 				remainingPercent,
 				threshold: settings.lowRemainingNotificationThreshold
 			});
+			const snapshotUpdatedAt = parseRateLimitTimestamp(payload.snapshot.lastUpdated);
+			recordAutoRollActivitySafe({
+				kind: "low-remaining-alert",
+				status: "sent",
+				profileName: payload.profileName,
+				remainingPercent,
+				threshold: settings.lowRemainingNotificationThreshold,
+				snapshotAgeMs: snapshotUpdatedAt === null ? null : Math.max(0, Date.now() - snapshotUpdatedAt),
+				snapshotSource: "event",
+				profileKey: payload.accountId
+			});
 		}
 	};
 	const publishProfileSwitched = (payload) => {
@@ -84231,6 +84208,7 @@ const createServer = fn(function* () {
 	let backgroundAutoRollInFlight = false;
 	let lastAutoRollAttempt = null;
 	const autoRollRearmBlockedProfiles = /* @__PURE__ */ new Set();
+	const lastAutoRollWatchdogActivityAt = /* @__PURE__ */ new Map();
 	const rememberAutoRollAttempt = (source, target) => {
 		if (!source || !target) return;
 		lastAutoRollAttempt = {
@@ -84270,6 +84248,19 @@ const createServer = fn(function* () {
 		const profile = (await profileManager.listProfiles()).find((entry) => entry.name === profileName);
 		return profile ? resolveProfileIdentityKeyFromProfile(profile) : null;
 	};
+	const hashIdentityKey = (key) => key ? createHash("sha256").update(key).digest("hex").slice(0, 12) : null;
+	const observedOfficialCodexProfileMatches = (instance, targetProfileName, targetProfileKey) => {
+		if (targetProfileKey && instance.profileKey) return instance.profileKey === targetProfileKey;
+		if (instance.profileKey) return false;
+		return Boolean(targetProfileName && instance.profileName === targetProfileName);
+	};
+	const recordAutoRollActivitySafe = async (input) => {
+		try {
+			await recordOfficialCodexActivity(input);
+		} catch (error) {
+			logger.warn("Failed to record auto-roll activity", { error });
+		}
+	};
 	const prepareOfficialCodexProfileLaunch = async (profileName) => {
 		const profile = (await profileManager.listProfiles()).find((entry) => entry.name === profileName);
 		if (!profile) throw new Error(`Profile '${profileName}' was not found.`);
@@ -84332,17 +84323,68 @@ const createServer = fn(function* () {
 		}
 		return null;
 	};
+	const mapOfficialCodexAppAccountToProfile = async () => {
+		const scopePath = nodePath.join(nodeOs.homedir(), "Library", "Application Support", "Codex", "sentry", "scope_v3.json");
+		let parsed;
+		try {
+			parsed = JSON.parse(await promises.readFile(scopePath, "utf8"));
+		} catch {
+			return null;
+		}
+		const scope = parsed && typeof parsed === "object" ? parsed.scope : null;
+		const user = scope && typeof scope === "object" ? scope.user : null;
+		if (!user || typeof user !== "object") return null;
+		const userRecord = user;
+		const ids = new Set([userRecord.account_id, userRecord.id].filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean));
+		if (ids.size === 0) return null;
+		const profiles = await profileManager.listProfiles();
+		for (const profile of profiles) if ([
+			profile.accountId,
+			profile.metadata?.chatgptAccountUserId,
+			profile.metadata?.chatgptUserId,
+			profile.metadata?.userId,
+			resolveProfileIdentityKeyFromProfile(profile)
+		].filter((value) => typeof value === "string" && value.length > 0).some((value) => ids.has(value))) return {
+			name: profile.name,
+			key: resolveProfileIdentityKeyFromProfile(profile)
+		};
+		return null;
+	};
 	const enrichOfficialCodexInstances = async (payload) => {
 		if (payload.unmanaged.length === 0) return payload;
-		const defaultProfile = await mapDefaultCodexAuthToProfile();
-		if (!defaultProfile) return payload;
+		const hasManagedRunning = payload.instances.some((instance) => instance.running);
+		const [defaultProfile, appAccountProfile, appState] = await Promise.all([
+			mapDefaultCodexAuthToProfile(),
+			!hasManagedRunning && payload.unmanaged.length === 1 && payload.unmanaged[0]?.appServerPid ? mapOfficialCodexAppAccountToProfile() : Promise.resolve(null),
+			getAppState()
+		]);
+		const lastProfileSwitchAt = appState.officialCodex.lastProfileSwitchAt;
+		const lastObservedPid = appState.officialCodex.lastObservedPid;
+		const lastVerifiedLaunchProfileKey = appState.officialCodex.lastVerifiedLaunchProfileKey;
+		const isFreshDefaultAuthObservation = (instance) => {
+			if (!defaultProfile) return false;
+			if (lastObservedPid && instance.pid === lastObservedPid && lastVerifiedLaunchProfileKey === defaultProfile.key) return true;
+			if (!lastProfileSwitchAt) return true;
+			const startedAt = parseRateLimitTimestamp(instance.startedAt);
+			return startedAt !== null && startedAt >= lastProfileSwitchAt - 1e3;
+		};
 		return {
 			...payload,
-			unmanaged: payload.unmanaged.map((instance) => instance.profileName || !instance.appServerPid ? instance : {
-				...instance,
-				profileName: defaultProfile.name,
-				profileKey: defaultProfile.key,
-				profileMatchSource: "default-auth"
+			unmanaged: payload.unmanaged.map((instance) => {
+				if (instance.profileName || !instance.appServerPid) return instance;
+				if (appAccountProfile) return {
+					...instance,
+					profileName: appAccountProfile.name,
+					profileKey: appAccountProfile.key,
+					profileMatchSource: "app-account"
+				};
+				if (defaultProfile && isFreshDefaultAuthObservation(instance)) return {
+					...instance,
+					profileName: defaultProfile.name,
+					profileKey: defaultProfile.key,
+					profileMatchSource: "default-auth"
+				};
+				return instance;
 			})
 		};
 	};
@@ -84356,6 +84398,62 @@ const createServer = fn(function* () {
 			bundleId: instances.bundleId
 		} : null;
 	};
+	const resolveOfficialCodexStatus = async (currentProfile) => {
+		const currentProfileKey = currentProfile ? resolveProfileIdentityKeyFromProfile(currentProfile) : null;
+		const base = await getOfficialCodexSyncStatus(currentProfileKey);
+		if (base.state === "unsupported" || base.state === "not-found" || base.state === "not-running") return base;
+		try {
+			const instances = await enrichOfficialCodexInstances(await getOfficialCodexProfileInstances());
+			const managed = instances.instances.filter((instance) => instance.running).map((instance) => ({
+				profileName: instance.profileName,
+				profileKey: instance.profileKey,
+				pid: instance.pid,
+				source: "managed"
+			}));
+			const unmanaged = instances.unmanaged.map((instance) => ({
+				profileName: instance.profileName ?? null,
+				profileKey: instance.profileKey ?? null,
+				pid: instance.pid,
+				source: instance.profileMatchSource ?? null
+			}));
+			const observedCandidates = unmanaged;
+			const observed = observedCandidates.find((instance) => observedOfficialCodexProfileMatches(instance, currentProfile?.name ?? null, currentProfileKey)) ?? observedCandidates.find((instance) => instance.profileName || instance.profileKey) ?? null;
+			if (!observed) {
+				if (managed.length > 0 && unmanaged.length === 0) return {
+					...base,
+					state: "not-running",
+					runningPids: [],
+					observedProfileName: null,
+					observedProfileKeyHash: null,
+					observedProfileMatchSource: null
+				};
+				if (base.state === "stale") return {
+					...base,
+					observedProfileName: null,
+					observedProfileKeyHash: null,
+					observedProfileMatchSource: null
+				};
+				return base;
+			}
+			const matched = Boolean(observedOfficialCodexProfileMatches(observed, currentProfile?.name ?? null, currentProfileKey));
+			if (matched && currentProfileKey && observed.pid) try {
+				const stored = (await getAppState()).officialCodex;
+				if (stored.lastVerifiedLaunchProfileKey !== currentProfileKey || stored.lastObservedPid !== observed.pid) await recordOfficialCodexProfileObservation(currentProfileKey, observed.pid);
+			} catch (error) {
+				logger.warn("Failed to record observed Official Codex profile", { error });
+			}
+			return {
+				...base,
+				state: currentProfile ? matched ? "synced" : "stale" : base.state,
+				observedProfileName: observed.profileName,
+				observedProfileKeyHash: hashIdentityKey(observed.profileKey),
+				observedProfileMatchSource: observed.source
+			};
+		} catch (error) {
+			logger.warn("Failed to resolve observed Official Codex profile", { error });
+			return base;
+		}
+	};
 	const resolveAutoRollRearmActionAfterManualSwitch = async (profileName) => {
 		const settings = normalizeAutoRollSettings(await getStoredAutoRollSettings());
 		if (!settings.enabled) return "none";
@@ -84366,30 +84464,414 @@ const createServer = fn(function* () {
 		if (!summary.hasUsage) return "unblock";
 		return summary.remainingPercent <= settings.switchRemainingThreshold ? "block" : "unblock";
 	};
-	const maybeRestartOfficialCodexAfterAutoRoll = async (targetProfileName, targetProfileKey) => {
+	const OFFICIAL_CODEX_RESTART_DEBT_MAX_ATTEMPTS = 5;
+	const OFFICIAL_CODEX_RESTART_RETRY_DELAY_MS = 61e3;
+	const OFFICIAL_CODEX_POST_RESTART_VERIFY_TIMEOUT_MS = 15e3;
+	const OFFICIAL_CODEX_POST_RESTART_VERIFY_INTERVAL_MS = 750;
+	let officialCodexRestartRetryTimer = null;
+	let officialCodexRestartDebt = null;
+	const persistOfficialCodexRestartDebt = async (debt) => {
+		await patchAppState({ officialCodex: { pendingRestartDebt: debt } });
+	};
+	const clearOfficialCodexRestartDebtLocal = () => {
+		officialCodexRestartDebt = null;
+		if (officialCodexRestartRetryTimer) {
+			clearTimeout(officialCodexRestartRetryTimer);
+			officialCodexRestartRetryTimer = null;
+		}
+	};
+	const clearOfficialCodexRestartDebt = async () => {
+		clearOfficialCodexRestartDebtLocal();
+		await persistOfficialCodexRestartDebt(null);
+	};
+	const rememberOfficialCodexRestartDebt = async (targetProfileName, targetProfileKey, reason, decisionId = null, sourceProfileName, sourceProfileKey) => {
+		const previous = officialCodexRestartDebt?.targetProfileName === targetProfileName ? officialCodexRestartDebt : null;
+		officialCodexRestartDebt = {
+			targetProfileName,
+			targetProfileKey,
+			sourceProfileName: sourceProfileName !== void 0 ? sourceProfileName : previous?.sourceProfileName ?? null,
+			sourceProfileKey: sourceProfileKey !== void 0 ? sourceProfileKey : previous?.sourceProfileKey ?? null,
+			decisionId: decisionId ?? previous?.decisionId ?? null,
+			attempts: previous?.attempts ?? 0,
+			lastReason: reason
+		};
+		await persistOfficialCodexRestartDebt(officialCodexRestartDebt);
+	};
+	const getOfficialCodexRestartDebt = async () => {
+		if (officialCodexRestartDebt) return officialCodexRestartDebt;
+		const stored = (await getAppState()).officialCodex.pendingRestartDebt;
+		if (!stored) return null;
+		officialCodexRestartDebt = {
+			...stored,
+			attempts: Math.max(0, stored.attempts)
+		};
+		return officialCodexRestartDebt;
+	};
+	const resolveObservedOfficialCodexProfileMatch = async (targetProfileName, targetProfileKey) => {
+		const instances = await enrichOfficialCodexInstances(await getOfficialCodexProfileInstances());
+		const observed = [...instances.instances.filter((instance) => instance.running).map((instance) => ({
+			profileName: instance.profileName,
+			profileKey: instance.profileKey,
+			pid: instance.pid,
+			appServerPid: instance.appServerPid,
+			source: "managed"
+		})), ...instances.unmanaged.map((instance) => ({
+			profileName: instance.profileName ?? null,
+			profileKey: instance.profileKey ?? null,
+			pid: instance.pid,
+			appServerPid: instance.appServerPid,
+			source: instance.profileMatchSource ?? null
+		}))].filter((instance) => instance.profileName || instance.profileKey || instance.pid);
+		const matchedObserved = observed.find((instance) => observedOfficialCodexProfileMatches(instance, targetProfileName, targetProfileKey)) ?? null;
+		const restartableObserved = observed.filter((instance) => instance.source !== "managed" && instance.pid);
+		const singletonRestartableObserved = restartableObserved.length === 1 ? restartableObserved[0] : null;
+		const firstObserved = matchedObserved ?? singletonRestartableObserved ?? observed[0] ?? null;
+		return {
+			matched: Boolean(matchedObserved),
+			canStopObservedWindow: Boolean(firstObserved?.pid && firstObserved.source !== "managed" && (matchedObserved || singletonRestartableObserved === firstObserved)),
+			ambiguousRestartableWindow: !matchedObserved && restartableObserved.length > 1,
+			state: instances.state,
+			observedProfileName: firstObserved?.profileName ?? null,
+			observedProfileKey: firstObserved?.profileKey ?? null,
+			observedProfileMatchSource: firstObserved?.source ?? null,
+			pid: firstObserved?.pid ?? null,
+			appServerPid: firstObserved?.appServerPid ?? null
+		};
+	};
+	const recordTargetedOfficialCodexRestartResult = async (payload, targetProfileName, targetProfileKey, decisionId) => {
+		const pid = payload.status === "started" || payload.status === "restarted" ? payload.pid : null;
+		const reason = payload.status === "skipped" || payload.status === "failed" ? payload.reason : null;
+		await recordOfficialCodexRestartResult({
+			status: payload.status,
+			reason,
+			profileKey: targetProfileKey,
+			pid
+		});
+		await recordAutoRollActivitySafe({
+			kind: "official-codex-restart",
+			status: payload.status,
+			reason,
+			decisionId,
+			targetProfileName,
+			profileKey: targetProfileKey,
+			phase: payload.status === "failed" ? payload.phase ?? null : "profile",
+			pid,
+			restartRequested: true,
+			restartResult: payload.status
+		});
+	};
+	const profileActionToRestartPayload = (action, runningStatus, failedPhase) => {
+		if (action.status === "failed") return {
+			status: "failed",
+			appPath: action.instance?.appPath ?? void 0,
+			bundleId: action.instance?.bundleId ?? void 0,
+			reason: action.reason ?? "official-codex-profile-action-failed",
+			phase: failedPhase
+		};
+		if (action.status === "started" || action.status === "restarted") return {
+			status: runningStatus,
+			appPath: action.instance?.appPath ?? "",
+			bundleId: action.instance?.bundleId ?? "",
+			pid: action.instance?.pid ?? null
+		};
+		if (action.status === "already-running") return {
+			status: "skipped",
+			reason: "already-running"
+		};
+		if (action.status === "skipped" || action.status === "not-running") return {
+			status: "skipped",
+			reason: action.reason ?? "official-codex-app-not-running"
+		};
+		return {
+			status: "skipped",
+			reason: action.status
+		};
+	};
+	const restartOfficialCodexProfileTarget = async (args) => {
+		await recordAutoRollActivitySafe({
+			kind: "official-codex-restart",
+			status: "started",
+			reason: null,
+			decisionId: args.decisionId,
+			targetProfileName: args.targetProfileName,
+			profileKey: args.targetProfileKey,
+			phase: "profile",
+			restartRequested: true
+		});
+		const observed = await resolveObservedOfficialCodexProfileMatch(args.targetProfileName, args.targetProfileKey);
+		const canRestartManagedWindow = Boolean(observed.pid !== null && observed.observedProfileMatchSource === "managed" && observed.matched);
+		const canStopMatchedObservedWindow = Boolean(observed.pid !== null && observed.matched && observed.observedProfileMatchSource !== "managed" && observed.canStopObservedWindow);
+		const observedMatchesSource = !observed.matched && Boolean(args.sourceProfileName || args.sourceProfileKey) && observedOfficialCodexProfileMatches({
+			profileName: observed.observedProfileName,
+			profileKey: observed.observedProfileKey
+		}, args.sourceProfileName ?? null, args.sourceProfileKey ?? null);
+		const canStopSourceManagedWindow = Boolean(observed.pid !== null && observedMatchesSource && observed.observedProfileMatchSource === "managed" && args.sourceProfileName);
+		const canStopSourceObservedWindow = Boolean(observed.pid !== null && observedMatchesSource && observed.observedProfileMatchSource !== "managed" && observed.canStopObservedWindow);
+		const hasRestartableWindow = canRestartManagedWindow || canStopMatchedObservedWindow || canStopSourceManagedWindow || canStopSourceObservedWindow;
+		if (!hasRestartableWindow && observed.ambiguousRestartableWindow) {
+			const skipped = {
+				status: "skipped",
+				reason: "ambiguous-official-codex-windows"
+			};
+			await recordTargetedOfficialCodexRestartResult(skipped, args.targetProfileName, args.targetProfileKey, args.decisionId);
+			return skipped;
+		}
+		if (!hasRestartableWindow && !args.launchIfNotRunning) {
+			const skipped = {
+				status: "skipped",
+				reason: observed.state === "unsupported" ? "unsupported-platform" : observed.state === "not-found" ? "official-codex-app-not-found" : observed.pid !== null ? "unverified-official-codex-window" : "official-codex-app-not-running"
+			};
+			await recordTargetedOfficialCodexRestartResult(skipped, args.targetProfileName, args.targetProfileKey, args.decisionId);
+			return skipped;
+		}
+		const options = await prepareOfficialCodexProfileLaunch(args.targetProfileName);
+		if (observed.observedProfileMatchSource === "managed" && observed.matched) {
+			const payload = profileActionToRestartPayload(await restartOfficialCodexProfileInstance(options), "restarted", "profile");
+			await recordTargetedOfficialCodexRestartResult(payload, args.targetProfileName, args.targetProfileKey, args.decisionId);
+			return payload;
+		}
+		let stoppedRunningWindow = false;
+		if (canStopMatchedObservedWindow && observed.pid !== null) {
+			const stopped = await stopOfficialCodexObservedProfileInstance(observed.observedProfileName ?? args.targetProfileName, observed.pid, observed.appServerPid);
+			if (stopped.status === "failed") {
+				const failed = profileActionToRestartPayload(stopped, "restarted", "quit");
+				await recordTargetedOfficialCodexRestartResult(failed, args.targetProfileName, args.targetProfileKey, args.decisionId);
+				return failed;
+			}
+			stoppedRunningWindow = stopped.status === "stopped";
+		} else if (canStopSourceManagedWindow && args.sourceProfileName) {
+			const stopped = await stopOfficialCodexProfileInstance(args.sourceProfileName);
+			if (stopped.status === "failed") {
+				const failed = profileActionToRestartPayload(stopped, "restarted", "quit");
+				await recordTargetedOfficialCodexRestartResult(failed, args.targetProfileName, args.targetProfileKey, args.decisionId);
+				return failed;
+			}
+			stoppedRunningWindow = stopped.status === "stopped";
+		} else if (canStopSourceObservedWindow && observed.pid !== null) {
+			const stopped = await stopOfficialCodexObservedProfileInstance(observed.observedProfileName ?? args.sourceProfileName ?? args.targetProfileName, observed.pid, observed.appServerPid);
+			if (stopped.status === "failed") {
+				const failed = profileActionToRestartPayload(stopped, "restarted", "quit");
+				await recordTargetedOfficialCodexRestartResult(failed, args.targetProfileName, args.targetProfileKey, args.decisionId);
+				return failed;
+			}
+			stoppedRunningWindow = stopped.status === "stopped";
+		}
+		const payload = profileActionToRestartPayload(await launchOfficialCodexProfileInstance(options), stoppedRunningWindow ? "restarted" : "started", "launch");
+		await recordTargetedOfficialCodexRestartResult(payload, args.targetProfileName, args.targetProfileKey, args.decisionId);
+		return payload;
+	};
+	const waitForOfficialCodexProfileMatch = async (targetProfileName, targetProfileKey) => {
+		const deadline = Date.now() + OFFICIAL_CODEX_POST_RESTART_VERIFY_TIMEOUT_MS;
+		let latest = await resolveObservedOfficialCodexProfileMatch(targetProfileName, targetProfileKey);
+		while (!latest.matched && Date.now() < deadline) {
+			await new Promise((resolve) => setTimeout(resolve, OFFICIAL_CODEX_POST_RESTART_VERIFY_INTERVAL_MS));
+			latest = await resolveObservedOfficialCodexProfileMatch(targetProfileName, targetProfileKey);
+		}
+		return latest;
+	};
+	const scheduleOfficialCodexRestartRetry = () => {
+		const debt = officialCodexRestartDebt;
+		if (!debt || officialCodexRestartRetryTimer) return;
+		if (debt.attempts >= OFFICIAL_CODEX_RESTART_DEBT_MAX_ATTEMPTS) {
+			clearOfficialCodexRestartDebt().catch((error) => {
+				logger.warn("Failed to clear Official Codex restart debt", { error });
+			});
+			recordAutoRollActivitySafe({
+				kind: "official-codex-restart",
+				status: "skipped",
+				reason: "restart-retry-exhausted",
+				decisionId: debt.decisionId,
+				targetProfileName: debt.targetProfileName,
+				profileKey: debt.targetProfileKey,
+				restartRequested: false,
+				restartResult: "skipped"
+			});
+			return;
+		}
+		const delayMs = Math.min(5 * 6e4, OFFICIAL_CODEX_RESTART_RETRY_DELAY_MS * Math.max(1, debt.attempts + 1));
+		officialCodexRestartRetryTimer = setTimeout(() => {
+			officialCodexRestartRetryTimer = null;
+			(async () => {
+				const debt = officialCodexRestartDebt;
+				if (!debt) return;
+				if ((await resolveObservedOfficialCodexProfileMatch(debt.targetProfileName, debt.targetProfileKey)).matched) {
+					await clearOfficialCodexRestartDebt();
+					return;
+				}
+				if (officialCodexRestartDebt) {
+					officialCodexRestartDebt = {
+						...officialCodexRestartDebt,
+						attempts: officialCodexRestartDebt.attempts + 1
+					};
+					await persistOfficialCodexRestartDebt(officialCodexRestartDebt);
+					await maybeRestartOfficialCodexAfterAutoRoll(officialCodexRestartDebt.targetProfileName, officialCodexRestartDebt.targetProfileKey, officialCodexRestartDebt.decisionId, officialCodexRestartDebt.sourceProfileName, officialCodexRestartDebt.sourceProfileKey);
+				}
+			})().catch((error) => {
+				logger.warn("Official Codex restart retry failed", { error });
+			});
+		}, delayMs);
+		officialCodexRestartRetryTimer.unref?.();
+	};
+	const reconcileOfficialCodexRestartDebt = async () => {
+		const debt = await getOfficialCodexRestartDebt();
+		if (!debt) return;
+		const settings = normalizeAutoRollSettings(await getStoredAutoRollSettings());
+		if (!settings.restartOfficialCodexOnAutoRoll) {
+			await clearOfficialCodexRestartDebt();
+			return;
+		}
+		const targetProfile = (await profileManager.listProfiles()).find((profile) => profile.name === debt.targetProfileName) ?? null;
+		if ((await resolveObservedOfficialCodexProfileMatch(debt.targetProfileName, debt.targetProfileKey)).matched) {
+			await clearOfficialCodexRestartDebt();
+			return;
+		}
+		const status = targetProfile ? await resolveOfficialCodexStatus(targetProfile) : await getOfficialCodexSyncStatus(debt.targetProfileKey);
+		if (status.state === "synced") {
+			await rememberOfficialCodexRestartDebt(debt.targetProfileName, debt.targetProfileKey, "launched-auth-unverified", debt.decisionId);
+			scheduleOfficialCodexRestartRetry();
+			return;
+		}
+		if (status.state === "not-running" && !settings.launchOfficialCodexWhenClosedOnAutoRoll) {
+			await clearOfficialCodexRestartDebt();
+			return;
+		}
+		if (status.state === "stale" || status.state === "unknown" || status.state === "not-running" && settings.launchOfficialCodexWhenClosedOnAutoRoll) scheduleOfficialCodexRestartRetry();
+	};
+	const maybeRestartOfficialCodexAfterAutoRoll = async (targetProfileName, targetProfileKey, decisionId, sourceProfileName = null, sourceProfileKey = null) => {
 		try {
 			const settings = normalizeAutoRollSettings(await getStoredAutoRollSettings());
-			if (!settings.restartOfficialCodexOnAutoRoll) return;
-			const result = await restartOfficialCodexApp({
-				source: "auto-roll",
-				currentProfileKey: targetProfileKey,
-				launchIfNotRunning: settings.launchOfficialCodexWhenClosedOnAutoRoll
+			if (!settings.restartOfficialCodexOnAutoRoll) {
+				await clearOfficialCodexRestartDebt();
+				return;
+			}
+			const alreadyMatched = await resolveObservedOfficialCodexProfileMatch(targetProfileName, targetProfileKey);
+			if (alreadyMatched.matched) {
+				await clearOfficialCodexRestartDebt();
+				await recordAutoRollActivitySafe({
+					kind: "official-codex-restart",
+					status: "skipped",
+					reason: "already-synced",
+					decisionId,
+					targetProfileName,
+					profileKey: targetProfileKey,
+					restartRequested: false,
+					restartResult: "skipped",
+					observedProfileName: alreadyMatched.observedProfileName,
+					observedProfileKey: alreadyMatched.observedProfileKey,
+					observedProfileMatchSource: alreadyMatched.observedProfileMatchSource
+				});
+				return;
+			}
+			await rememberOfficialCodexRestartDebt(targetProfileName, targetProfileKey, null, decisionId, sourceProfileName, sourceProfileKey);
+			const result = await restartOfficialCodexProfileTarget({
+				targetProfileName,
+				targetProfileKey,
+				sourceProfileName,
+				sourceProfileKey,
+				launchIfNotRunning: settings.launchOfficialCodexWhenClosedOnAutoRoll,
+				decisionId
 			});
 			trackAnalyticsEvent("official_codex_restart_after_auto_roll", {
 				status: result.status,
-				reason: result.status === "skipped" || result.status === "failed" ? result.reason : void 0,
-				targetProfileName
+				reason: result.status === "skipped" || result.status === "failed" ? result.reason : void 0
 			});
+			if (result.status === "skipped" && result.reason === "cooldown") {
+				await rememberOfficialCodexRestartDebt(targetProfileName, targetProfileKey, "cooldown", decisionId);
+				await reconcileOfficialCodexRestartDebt();
+			} else if (result.status === "skipped" && result.reason === "official-codex-app-not-running" && !settings.launchOfficialCodexWhenClosedOnAutoRoll) await clearOfficialCodexRestartDebt();
+			else if (result.status === "skipped" || result.status === "failed") {
+				await rememberOfficialCodexRestartDebt(targetProfileName, targetProfileKey, result.reason, decisionId);
+				await reconcileOfficialCodexRestartDebt();
+			} else {
+				const verified = await waitForOfficialCodexProfileMatch(targetProfileName, targetProfileKey);
+				if (verified.matched) {
+					await recordAutoRollActivitySafe({
+						kind: "official-codex-restart",
+						status: "auth-verified",
+						reason: null,
+						decisionId,
+						targetProfileName,
+						profileKey: targetProfileKey,
+						restartRequested: true,
+						restartResult: result.status,
+						observedProfileName: verified.observedProfileName,
+						observedProfileKey: verified.observedProfileKey,
+						observedProfileMatchSource: verified.observedProfileMatchSource
+					});
+					await clearOfficialCodexRestartDebt();
+				} else {
+					await rememberOfficialCodexRestartDebt(targetProfileName, targetProfileKey, "launched-auth-unverified", decisionId);
+					await recordAutoRollActivitySafe({
+						kind: "official-codex-restart",
+						status: "waiting",
+						reason: "launched-auth-unverified",
+						decisionId,
+						targetProfileName,
+						profileKey: targetProfileKey,
+						restartRequested: true,
+						restartResult: result.status,
+						observedProfileName: verified.observedProfileName,
+						observedProfileKey: verified.observedProfileKey,
+						observedProfileMatchSource: verified.observedProfileMatchSource
+					});
+					await reconcileOfficialCodexRestartDebt();
+				}
+			}
 			if (result.status === "failed") logger.warn("Official Codex restart after auto-roll failed", result);
 			else if (result.status === "restarted" || result.status === "started") logger.info("Official Codex restarted after auto-roll", result);
 		} catch (error) {
+			await rememberOfficialCodexRestartDebt(targetProfileName, targetProfileKey, error instanceof Error ? error.message : "restart-threw", decisionId);
+			await recordAutoRollActivitySafe({
+				kind: "official-codex-restart",
+				status: "failed",
+				reason: error instanceof Error ? error.message : "restart-threw",
+				decisionId,
+				targetProfileName,
+				profileKey: targetProfileKey,
+				restartRequested: true,
+				restartResult: "failed"
+			});
+			scheduleOfficialCodexRestartRetry();
 			logger.warn("Official Codex restart after auto-roll threw", { error });
 		}
 	};
-	const handleProfileSwitch = async (name, source = "app") => {
+	const handleProfileSwitch = async (name, source = "app", decisionContext = {}) => {
 		if (!name) throw new Error("Profile name is required");
 		const previousProfile = source === "auto-roll" ? (await profileManager.getCurrentProfile()).name ?? null : null;
+		const previousProfileKey = source === "auto-roll" ? await resolveProfileIdentityKeyByName(previousProfile) : null;
 		await profileManager.switchToProfile(name);
+		if (source === "auto-roll") {
+			const verified = await profileManager.getCurrentProfile();
+			if (verified.name !== name || !verified.trusted) {
+				await recordAutoRollActivitySafe({
+					kind: "auth-verified",
+					status: "failed",
+					reason: "active-auth-mismatch-after-switch",
+					decisionId: decisionContext.decisionId,
+					sourceProfileName: previousProfile,
+					targetProfileName: name,
+					remainingPercent: decisionContext.remainingPercent,
+					threshold: decisionContext.threshold,
+					snapshotAgeMs: decisionContext.snapshotAgeMs,
+					snapshotSource: decisionContext.snapshotSource,
+					switchVerified: false
+				});
+				throw new Error("Auto-roll profile switch did not verify active Codex auth.");
+			}
+			await recordAutoRollActivitySafe({
+				kind: "auth-verified",
+				status: "ok",
+				reason: null,
+				decisionId: decisionContext.decisionId,
+				sourceProfileName: previousProfile,
+				targetProfileName: name,
+				remainingPercent: decisionContext.remainingPercent,
+				threshold: decisionContext.threshold,
+				snapshotAgeMs: decisionContext.snapshotAgeMs,
+				snapshotSource: decisionContext.snapshotSource,
+				switchVerified: true
+			});
+		}
 		let targetProfileKey = null;
 		try {
 			targetProfileKey = await resolveProfileIdentityKeyByName(name);
@@ -84400,8 +84882,24 @@ const createServer = fn(function* () {
 				profileName: name
 			});
 		}
-		if (source === "auto-roll") rememberAutoRollAttempt(previousProfile, name);
-		else try {
+		if (source === "auto-roll") {
+			rememberAutoRollAttempt(previousProfile, name);
+			await recordAutoRollActivitySafe({
+				kind: "profile-switch",
+				status: "completed",
+				reason: null,
+				decisionId: decisionContext.decisionId,
+				sourceProfileName: previousProfile,
+				targetProfileName: name,
+				remainingPercent: decisionContext.remainingPercent,
+				threshold: decisionContext.threshold,
+				snapshotAgeMs: decisionContext.snapshotAgeMs,
+				snapshotSource: decisionContext.snapshotSource,
+				profileKey: targetProfileKey,
+				switchVerified: true,
+				restartRequested: decisionContext.restartRequested ?? null
+			});
+		} else try {
 			const rearmAction = await resolveAutoRollRearmActionAfterManualSwitch(name);
 			if (rearmAction === "block") blockAutoRollUntilRearm(name);
 			else if (rearmAction === "unblock") unblockAutoRollRearm(name);
@@ -84413,10 +84911,13 @@ const createServer = fn(function* () {
 		}
 		await publishProfileSwitched({ name });
 		trackAnalyticsEvent("profile_switched", { source });
-		if (source === "auto-roll") await maybeRestartOfficialCodexAfterAutoRoll(name, targetProfileKey);
+		if (source === "auto-roll") await maybeRestartOfficialCodexAfterAutoRoll(name, targetProfileKey, decisionContext.decisionId ?? null, previousProfile, previousProfileKey);
+		else maybeRunBackgroundAutoRoll();
 	};
 	const maybeRunBackgroundAutoRoll = async () => {
 		if (backgroundAutoRollInFlight) return;
+		const decisionId = createAutoRollDecisionId();
+		let lastDecisionContext = { decisionId };
 		backgroundAutoRollInFlight = true;
 		try {
 			const settings = normalizeAutoRollSettings(await getStoredAutoRollSettings());
@@ -84428,9 +84929,12 @@ const createServer = fn(function* () {
 			const profiles = await profileManager.listProfiles();
 			const snapshots = await loadCachedRateLimitSnapshots(profiles.map((profile) => resolveProfileIdentityKeyFromProfile(profile)));
 			const usageSummaries = /* @__PURE__ */ new Map();
+			const snapshotDiagnostics = /* @__PURE__ */ new Map();
 			const profilesWithSnapshots = profiles.map((profile) => {
 				const accountId = resolveProfileIdentityKeyFromProfile(profile);
-				const snapshot = snapshots.get(accountId) ?? profile.rateLimit ?? null;
+				const diagnostic = buildSnapshotDiagnostic(snapshots.get(accountId) ?? null, profile.rateLimit ?? null);
+				snapshotDiagnostics.set(profile.name, diagnostic);
+				const snapshot = freshAutoRollSnapshot(diagnostic.snapshot);
 				usageSummaries.set(profile.name, summarizeRateLimitSnapshot(snapshot));
 				return {
 					...profile,
@@ -84441,19 +84945,125 @@ const createServer = fn(function* () {
 			const currentProfile = profilesWithSnapshots.find((profile) => profile.name === currentProfileName);
 			if (!currentProfile) return;
 			const currentSummary = usageSummaries.get(currentProfileName) ?? summarizeRateLimitSnapshot(currentProfile.rateLimit ?? null);
+			const currentSnapshotDiagnostic = snapshotDiagnostics.get(currentProfileName) ?? buildSnapshotDiagnostic(null, currentProfile.rateLimit ?? null);
+			const decisionContext = {
+				decisionId,
+				remainingPercent: currentSummary.hasUsage ? currentSummary.remainingPercent : null,
+				threshold: settings.switchRemainingThreshold,
+				snapshotAgeMs: currentSnapshotDiagnostic.ageMs,
+				snapshotSource: currentSnapshotDiagnostic.source,
+				restartRequested: settings.restartOfficialCodexOnAutoRoll
+			};
+			lastDecisionContext = decisionContext;
 			if (!currentSummary.hasUsage) return;
-			if (isAutoRollBlockedUntilRearm(currentProfileName, currentSummary, settings.rearmRemainingThreshold)) return;
+			if (isAutoRollBlockedUntilRearm(currentProfileName, currentSummary, settings.rearmRemainingThreshold)) {
+				await recordAutoRollActivitySafe({
+					kind: "auto-roll-eval",
+					status: "blocked",
+					reason: "waiting-for-rearm",
+					decisionId,
+					profileName: currentProfileName,
+					remainingPercent: currentSummary.remainingPercent,
+					threshold: settings.rearmRemainingThreshold,
+					snapshotAgeMs: currentSnapshotDiagnostic.ageMs,
+					snapshotSource: currentSnapshotDiagnostic.source
+				});
+				return;
+			}
 			if (currentSummary.remainingPercent > settings.switchRemainingThreshold) return;
+			await recordAutoRollActivitySafe({
+				kind: "auto-roll-eval",
+				status: "threshold-hit",
+				reason: null,
+				decisionId,
+				profileName: currentProfileName,
+				remainingPercent: currentSummary.remainingPercent,
+				threshold: settings.switchRemainingThreshold,
+				snapshotAgeMs: currentSnapshotDiagnostic.ageMs,
+				snapshotSource: currentSnapshotDiagnostic.source
+			});
 			const candidate = computeAutoRollCandidate(profilesWithSnapshots, usageSummaries, currentProfileName, currentSummary, settings.switchRemainingThreshold, settings.priorityOrder, autoRollRearmBlockedProfiles);
-			if (!candidate || isRecentAutoRollAttempt(currentProfileName, candidate.profile.name)) return;
-			await handleProfileSwitch(candidate.profile.name, "auto-roll");
+			if (!candidate) {
+				await recordAutoRollActivitySafe({
+					kind: "auto-roll-eval",
+					status: "skipped",
+					reason: "no-candidate",
+					decisionId,
+					profileName: currentProfileName,
+					remainingPercent: currentSummary.remainingPercent,
+					threshold: settings.switchRemainingThreshold,
+					snapshotAgeMs: currentSnapshotDiagnostic.ageMs,
+					snapshotSource: currentSnapshotDiagnostic.source
+				});
+				return;
+			}
+			if (isRecentAutoRollAttempt(currentProfileName, candidate.profile.name)) {
+				await recordAutoRollActivitySafe({
+					kind: "auto-roll-eval",
+					status: "skipped",
+					reason: "recent-duplicate-attempt",
+					decisionId,
+					sourceProfileName: currentProfileName,
+					targetProfileName: candidate.profile.name,
+					remainingPercent: currentSummary.remainingPercent,
+					threshold: settings.switchRemainingThreshold,
+					snapshotAgeMs: currentSnapshotDiagnostic.ageMs,
+					snapshotSource: currentSnapshotDiagnostic.source
+				});
+				return;
+			}
+			await handleProfileSwitch(candidate.profile.name, "auto-roll", decisionContext);
 			blockAutoRollUntilRearm(currentProfileName);
 		} catch (error) {
+			await recordAutoRollActivitySafe({
+				kind: "auto-roll-eval",
+				status: "failed",
+				reason: error instanceof Error ? error.message : "unknown-error",
+				decisionId,
+				remainingPercent: lastDecisionContext.remainingPercent,
+				threshold: lastDecisionContext.threshold,
+				snapshotAgeMs: lastDecisionContext.snapshotAgeMs,
+				snapshotSource: lastDecisionContext.snapshotSource
+			});
 			logger.warn("Background auto-roll failed", { error });
 		} finally {
 			backgroundAutoRollInFlight = false;
 		}
 	};
+	const runAutoRollWatchdog = async () => {
+		const decisionId = createAutoRollDecisionId();
+		const settings = normalizeAutoRollSettings(await getStoredAutoRollSettings());
+		if (!settings.enabled) return;
+		if (!(await licenseService.getCachedStatus()).isPro) return;
+		const current = await profileManager.getCurrentProfile();
+		const currentProfileName = typeof current.name === "string" && current.name.length > 0 ? current.name : null;
+		if (!currentProfileName) return;
+		const currentProfile = (await profileManager.listProfiles()).find((profile) => profile.name === currentProfileName) ?? null;
+		if (!currentProfile) return;
+		const accountId = resolveProfileIdentityKeyFromProfile(currentProfile);
+		const diagnostic = buildSnapshotDiagnostic((await loadCachedRateLimitSnapshots([accountId])).get(accountId) ?? null, currentProfile.rateLimit ?? null);
+		const snapshot = diagnostic.snapshot;
+		if (isSnapshotStaleForAutoRollWatchdog(snapshot)) {
+			const queued = await enqueueAccountsRefreshNow([currentProfileName]);
+			const lastRecordedAt = lastAutoRollWatchdogActivityAt.get(accountId) ?? 0;
+			if (queued.enqueuedAccountIds.includes(accountId) && Date.now() - lastRecordedAt >= AUTO_ROLL_WATCHDOG_ACTIVITY_TTL_MS) {
+				lastAutoRollWatchdogActivityAt.set(accountId, Date.now());
+				await recordAutoRollActivitySafe({
+					kind: "auto-roll-eval",
+					status: "refresh-queued",
+					reason: "watchdog-stale-snapshot",
+					decisionId,
+					profileName: currentProfileName,
+					threshold: settings.switchRemainingThreshold,
+					snapshotAgeMs: diagnostic.ageMs,
+					snapshotSource: diagnostic.source,
+					profileKey: accountId
+				});
+			}
+			return;
+		}
+		await maybeRunBackgroundAutoRoll();
+	};
 	const handleDesktopMessage = (message) => {
 		if (!isDesktopChildCommand(message)) return;
 		if (message.type === "t3-server:switch-profile") {
@@ -84484,6 +85094,7 @@ const createServer = fn(function* () {
 			logger.warn("Low remaining notification failed", { error });
 		});
 		maybeRunBackgroundAutoRoll();
+		reconcileOfficialCodexRestartDebt();
 	};
 	const handleRateLimitStateChanged = (payload) => {
 		refreshTray();
@@ -84491,9 +85102,16 @@ const createServer = fn(function* () {
 	};
 	rateLimitEvents.on("snapshot-updated", handleRateLimitSnapshotUpdated);
 	rateLimitEvents.on("refresh-state-changed", handleRateLimitStateChanged);
+	const autoRollWatchdogInterval = setInterval(() => {
+		runAutoRollWatchdog().catch((error) => {
+			logger.warn("Auto-roll watchdog failed", { error });
+		});
+	}, AUTO_ROLL_WATCHDOG_INTERVAL_MS);
+	autoRollWatchdogInterval.unref?.();
 	yield* addFinalizer(() => sync(() => {
 		rateLimitEvents.off("snapshot-updated", handleRateLimitSnapshotUpdated);
 		rateLimitEvents.off("refresh-state-changed", handleRateLimitStateChanged);
+		clearInterval(autoRollWatchdogInterval);
 	}));
 	const unsubscribeTerminalEvents = yield* terminalManager.subscribe((event) => void runPromise(pushBus.publishAll(WS_CHANNELS.terminalEvent, event)));
 	yield* addFinalizer(() => sync(() => unsubscribeTerminalEvents()));
@@ -84513,6 +85131,8 @@ const createServer = fn(function* () {
 		});
 	});
 	yield* readiness.markHttpListening;
+	maybeRunBackgroundAutoRoll();
+	reconcileOfficialCodexRestartDebt();
 	readResolvedTelegramRuntimeSettings().then((settings) => queueTelegramRuntimeSettingsApply(settings)).catch((error) => {
 		logger.warn("Failed to apply Telegram runtime settings during startup", { error: error instanceof Error ? error.message : String(error) });
 	});
@@ -84891,10 +85511,15 @@ const createServer = fn(function* () {
 				return yield* promise(() => telegramBridge.testToken(body.token));
 			}
 			case WS_METHODS.profilesFetch: {
-				const data = yield* promise(() => loadProfilesViewData({ autoImportActiveAuth: true }));
+				const body = request.body && typeof request.body === "object" ? stripRequestTag(request.body) : {};
+				const data = yield* promise(() => loadProfilesViewData({
+					autoImportActiveAuth: true,
+					backgroundRefresh: body.backgroundRefresh !== false
+				}));
 				const currentProfile = data.currentProfile ? data.profiles.find((profile) => profile.name === data.currentProfile) ?? null : null;
-				const currentProfileKey = currentProfile ? resolveProfileIdentityKeyFromProfile(currentProfile) : null;
-				const officialCodexStatus = yield* promise(() => getOfficialCodexSyncStatus(currentProfileKey));
+				const officialCodexStatus = yield* promise(() => resolveOfficialCodexStatus(currentProfile));
+				maybeRunBackgroundAutoRoll();
+				reconcileOfficialCodexRestartDebt();
 				refreshTray();
 				return {
 					...data,
@@ -85171,6 +85796,7 @@ const createServer = fn(function* () {
 				const normalized = normalizeAutoRollSettings(stripRequestTag(request.body).settings);
 				yield* promise(() => persistAutoRollSettings(normalized));
 				maybeRunBackgroundAutoRoll();
+				reconcileOfficialCodexRestartDebt();
 				trackAnalyticsEvent("auto_roll_settings_saved", {
 					enabled: normalized.enabled,
 					rearmRemainingThreshold: normalized.rearmRemainingThreshold,
@@ -85184,9 +85810,19 @@ const createServer = fn(function* () {
 				return normalized;
 			}
 			case WS_METHODS.officialCodexRestart: return yield* promise(async () => {
-				return restartOfficialCodexApp({
-					source: "manual",
-					currentProfileKey: await resolveProfileIdentityKeyByName((await profileManager.getCurrentProfile()).name ?? null)
+				const current = await profileManager.getCurrentProfile();
+				const currentProfileKey = await resolveProfileIdentityKeyByName(current.name ?? null);
+				if (!current.name) return {
+					status: "skipped",
+					reason: "profile-not-selected"
+				};
+				return restartOfficialCodexProfileTarget({
+					targetProfileName: current.name,
+					targetProfileKey: currentProfileKey,
+					sourceProfileName: null,
+					sourceProfileKey: null,
+					launchIfNotRunning: true,
+					decisionId: null
 				});
 			});
 			case WS_METHODS.officialCodexInstances: return yield* promise(async () => enrichOfficialCodexInstances(await getOfficialCodexProfileInstances()));