sneakoscope 8.0.2 → 8.0.3

package/dist/core/codex-app/menubar/launch-agent.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { exists, runProcess, which } from '../../fsx.js';
+import { exists, readJson, runProcess, which, writeJsonAtomic } from '../../fsx.js';
 import { CONTROL_CENTER_DOMAIN, CONTROL_CENTER_PREFERRED_POSITION, SKS_MENUBAR_LABEL } from './constants.js';
 export function launchAgentSource(executablePath, installDir) {
     return `<?xml version="1.0" encoding="UTF-8"?>
@@ -31,25 +31,45 @@ export async function seedMenuBarPreferredPosition(env) {
 export async function launchMenuBar(input) {
     const domain = launchDomain();
     const service = launchServiceName();
-    await runProcess(input.launchctl, ['bootout', service], { timeoutMs: 3_000, maxOutputBytes: 8 * 1024 }).catch(() => undefined);
-    await runProcess(input.launchctl, ['bootout', domain, input.paths.launch_agent_path], { timeoutMs: 3_000, maxOutputBytes: 8 * 1024 }).catch(() => undefined);
-    await terminateExistingMenuBarProcess(input.paths.executable_path);
+    if (!input.alreadyStopped) {
+        const stopped = await stopMenuBarForReplacement({
+            launchctl: input.launchctl,
+            paths: input.paths,
+            executablePaths: input.executablePaths || [input.paths.executable_path],
+            ...(input.env ? { env: input.env } : {})
+        });
+        if (!stopped.ok) {
+            return {
+                requested: true,
+                method: 'launchctl',
+                ok: false,
+                terminal_uncertain: stopped.timed_out,
+                error: stopped.error || 'menubar_stop_failed'
+            };
+        }
+    }
     const bootstrap = await runProcess(input.launchctl, ['bootstrap', domain, input.paths.launch_agent_path], {
         timeoutMs: timeoutFromEnv(input.env, 'SKS_MENUBAR_BOOTSTRAP_TIMEOUT_MS', 8_000),
         maxOutputBytes: 16 * 1024
     }).catch((error) => failedProcess(error));
     if (bootstrap.timedOut) {
         const probe = await waitForLaunchdServiceRunning(input.launchctl, service, input.env);
+        const versionProbe = input.expectedVersion && probe.running
+            ? await waitForRunningMenuBarVersion(input.paths, input.expectedVersion, probe.pid, input.env)
+            : undefined;
         return {
             requested: true,
             method: 'launchctl',
-            ok: probe.running,
+            ok: probe.running && (versionProbe?.ok ?? true),
             bootstrap_code: bootstrap.code,
             bootstrap_timed_out: true,
             print_code: probe.code,
             verified_running_after_timeout: probe.running,
             terminal_uncertain: !probe.running,
-            error: probe.running ? null : probe.error || 'launchctl_bootstrap_timed_out'
+            ...(versionProbe ? { version_probe: versionProbe } : {}),
+            error: probe.running
+                ? versionProbe?.error || null
+                : probe.error || 'launchctl_bootstrap_timed_out'
         };
     }
     if (bootstrap.code === 0) {
@@ -59,11 +79,14 @@ export async function launchMenuBar(input) {
         }).catch((error) => failedProcess(error));
         if (kickstart.code === 0 || kickstart.timedOut) {
             const probe = await waitForLaunchdServiceRunning(input.launchctl, service, input.env);
+            const versionProbe = input.expectedVersion && probe.running
+                ? await waitForRunningMenuBarVersion(input.paths, input.expectedVersion, probe.pid, input.env)
+                : undefined;
             const terminalUncertain = !probe.running && (kickstart.timedOut || probe.code !== 0);
             return {
                 requested: true,
                 method: 'launchctl',
-                ok: probe.running,
+                ok: probe.running && (versionProbe?.ok ?? true),
                 bootstrap_code: bootstrap.code,
                 bootstrap_timed_out: false,
                 kickstart_code: kickstart.code,
@@ -71,7 +94,10 @@ export async function launchMenuBar(input) {
                 print_code: probe.code,
                 verified_running_after_timeout: kickstart.timedOut && probe.running,
                 terminal_uncertain: terminalUncertain,
-                error: probe.running ? null : probe.error || (kickstart.timedOut ? 'launchctl_kickstart_timed_out' : 'launchctl_kickstart_not_running')
+                ...(versionProbe ? { version_probe: versionProbe } : {}),
+                error: probe.running
+                    ? versionProbe?.error || null
+                    : probe.error || (kickstart.timedOut ? 'launchctl_kickstart_timed_out' : 'launchctl_kickstart_not_running')
             };
         }
         return { requested: true, method: 'launchctl', ok: false, bootstrap_code: bootstrap.code, bootstrap_timed_out: false, kickstart_code: kickstart.code, kickstart_timed_out: false, error: String(kickstart.stderr || kickstart.stdout).trim() };
@@ -81,16 +107,20 @@ export async function launchMenuBar(input) {
             .catch((error) => ({ code: 1, stdout: '', stderr: error instanceof Error ? error.message : String(error) }));
         const running = opened.code === 0
             && await waitForMenuBarProcessRunning(input.paths.executable_path, input.env);
+        const versionProbe = input.expectedVersion && running
+            ? await waitForRunningMenuBarVersion(input.paths, input.expectedVersion, null, input.env)
+            : undefined;
         return {
             requested: true,
             method: 'open-fallback',
-            ok: running,
+            ok: running && (versionProbe?.ok ?? true),
             bootstrap_code: bootstrap.code,
             bootstrap_timed_out: false,
             open_code: opened.code,
             open_verified_running: running,
+            ...(versionProbe ? { version_probe: versionProbe } : {}),
             error: running
-                ? null
+                ? versionProbe?.error || null
                 : opened.code === 0
                     ? 'open_succeeded_process_not_running'
                     : String(opened.stderr || bootstrap.stderr).trim()
@@ -98,6 +128,86 @@ export async function launchMenuBar(input) {
     }
     return { requested: true, method: 'launchctl', ok: false, bootstrap_code: bootstrap.code, bootstrap_timed_out: false, error: String(bootstrap.stderr || bootstrap.stdout || 'launchctl_bootstrap_failed').trim() };
 }
+export async function stopMenuBarForReplacement(input) {
+    const service = launchServiceName();
+    const domain = launchDomain();
+    const bootoutTimeout = timeoutFromEnv(input.env, 'SKS_MENUBAR_BOOTOUT_TIMEOUT_MS', 5_000);
+    const bootoutResults = [await runProcess(input.launchctl, ['bootout', service], {
+            timeoutMs: bootoutTimeout,
+            maxOutputBytes: 16 * 1024
+        }).catch((error) => failedProcess(error))];
+    if (!bootoutAccepted(bootoutResults[0])) {
+        bootoutResults.push(await runProcess(input.launchctl, ['bootout', domain, input.paths.launch_agent_path], {
+            timeoutMs: bootoutTimeout,
+            maxOutputBytes: 16 * 1024
+        }).catch((error) => failedProcess(error)));
+    }
+    const bootoutVerified = bootoutResults.some(bootoutAccepted);
+    const bootoutTimedOut = bootoutResults.some((result) => result.timedOut);
+    if (!bootoutVerified || bootoutTimedOut) {
+        const executablePaths = [...new Set(input.executablePaths.map((value) => path.resolve(value)))];
+        const remaining = await exactMenuBarProcessIds(executablePaths, input.env);
+        return {
+            ok: false,
+            service,
+            executable_paths: executablePaths,
+            bootout_codes: bootoutResults.map((result) => result.code),
+            terminated_pids: [],
+            remaining_pids: remaining,
+            timed_out: bootoutTimedOut,
+            error: bootoutTimedOut
+                ? 'launchctl_bootout_timed_out'
+                : `launchctl_bootout_failed:${bootoutResults.map((result) => result.code ?? 'unknown').join(',')}`
+        };
+    }
+    const terminated = await terminateMenuBarProcesses(input.executablePaths, input.env);
+    const executablePaths = terminated.executable_paths;
+    const before = terminated.before_pids;
+    const remaining = terminated.remaining_pids;
+    const processTimedOut = terminated.timed_out;
+    return {
+        ok: !processTimedOut && !bootoutTimedOut && bootoutVerified,
+        service,
+        executable_paths: executablePaths,
+        bootout_codes: bootoutResults.map((result) => result.code),
+        terminated_pids: before.filter((pid) => !remaining.includes(pid)),
+        remaining_pids: remaining,
+        timed_out: bootoutTimedOut || processTimedOut,
+        error: bootoutTimedOut
+            ? 'launchctl_bootout_timed_out'
+            : !bootoutVerified
+                ? `launchctl_bootout_failed:${bootoutResults.map((result) => result.code ?? 'unknown').join(',')}`
+                : remaining.length > 0
+                    ? `menubar_process_stop_timed_out:${remaining.join(',')}`
+                    : null
+    };
+}
+export async function terminateMenuBarProcesses(requestedExecutablePaths, env = process.env) {
+    const executablePaths = [...new Set(requestedExecutablePaths.map((value) => path.resolve(value)))];
+    const before = await exactMenuBarProcessIds(executablePaths, env);
+    const pkill = await processTool(env, 'SKS_MENUBAR_PKILL', '/usr/bin/pkill');
+    if (before.length > 0 && pkill) {
+        await runProcess(pkill, exactProcessArguments(executablePaths), {
+            timeoutMs: 3_000,
+            maxOutputBytes: 8 * 1024
+        }).catch(() => undefined);
+    }
+    const readbackTimeout = timeoutFromEnv(env, 'SKS_MENUBAR_STOP_READBACK_TIMEOUT_MS', 5_000);
+    const interval = timeoutFromEnv(env, 'SKS_MENUBAR_STOP_READBACK_INTERVAL_MS', 100);
+    const deadline = Date.now() + readbackTimeout;
+    let remaining = await exactMenuBarProcessIds(executablePaths, env);
+    while (remaining.length > 0 && Date.now() < deadline) {
+        await delay(Math.min(interval, Math.max(1, deadline - Date.now())));
+        remaining = await exactMenuBarProcessIds(executablePaths, env);
+    }
+    return {
+        ok: remaining.length === 0,
+        executable_paths: executablePaths,
+        before_pids: before,
+        remaining_pids: remaining,
+        timed_out: remaining.length > 0
+    };
+}
 export async function inspectLaunchdService(env = process.env) {
     if (process.platform !== 'darwin')
         return { checked: false, ok: true, service: null, state: null, pid: null, error: null };
@@ -110,28 +220,42 @@ export async function restartLaunchAgent(paths, env) {
     const launchctl = env.SKS_MENUBAR_LAUNCHCTL || await which('launchctl').catch(() => null) || '/bin/launchctl';
     const open = env.SKS_MENUBAR_OPEN || await which('open').catch(() => null) || '/usr/bin/open';
     const service = launchServiceName();
+    const buildStamp = await readJson(paths.build_stamp_path, null);
+    const expectedVersion = typeof buildStamp?.package_version === 'string' ? buildStamp.package_version : null;
     const result = await runProcess(launchctl, ['kickstart', '-k', service], {
         timeoutMs: timeoutFromEnv(env, 'SKS_MENUBAR_KICKSTART_TIMEOUT_MS', 5_000),
         maxOutputBytes: 16 * 1024
     }).catch((error) => failedProcess(error));
     if (result.code === 0 || result.timedOut) {
         const probe = await waitForLaunchdServiceRunning(launchctl, service, env);
+        const versionProbe = probe.running && expectedVersion
+            ? await waitForRunningMenuBarVersion(paths, expectedVersion, probe.pid, env)
+            : undefined;
         const terminalUncertain = !probe.running && (result.timedOut || probe.code !== 0);
         return {
-            ok: probe.running,
+            ok: probe.running && (versionProbe?.ok ?? true),
             code: result.code,
             timed_out: result.timedOut,
             print_code: probe.code,
             verified_running_after_timeout: result.timedOut && probe.running,
             terminal_uncertain: terminalUncertain,
             recovered_via_bootstrap: false,
-            error: probe.running ? null : probe.error || (result.timedOut ? 'launchctl_kickstart_timed_out' : 'launchctl_kickstart_not_running'),
+            ...(versionProbe ? { version_probe: versionProbe } : {}),
+            error: probe.running
+                ? versionProbe?.error || null
+                : probe.error || (result.timedOut ? 'launchctl_kickstart_timed_out' : 'launchctl_kickstart_not_running'),
             paths
         };
     }
     const kickstartError = String(result.stderr || result.stdout).trim();
     if (await exists(paths.launch_agent_path) && await exists(paths.executable_path) && isUnloadableLaunchdKickstartError(kickstartError)) {
-        const launch = await launchMenuBar({ launchctl, open, paths, env });
+        const launch = await launchMenuBar({
+            launchctl,
+            open,
+            paths,
+            env,
+            ...(expectedVersion ? { expectedVersion } : {})
+        });
         return {
             ok: launch.ok,
             code: launch.kickstart_code ?? launch.bootstrap_code ?? result.code,
@@ -140,6 +264,7 @@ export async function restartLaunchAgent(paths, env) {
             verified_running_after_timeout: Boolean(launch.verified_running_after_timeout),
             terminal_uncertain: Boolean(launch.terminal_uncertain),
             recovered_via_bootstrap: true,
+            ...(launch.version_probe ? { version_probe: launch.version_probe } : {}),
             error: launch.error ?? (launch.ok ? null : kickstartError),
             paths
         };
@@ -156,6 +281,16 @@ export async function restartLaunchAgent(paths, env) {
         paths
     };
 }
+export function isLaunchdServiceAbsent(result) {
+    if (result.timedOut || result.code === 0)
+        return false;
+    const output = `${result.stdout || ''}\n${result.stderr || ''}`;
+    return /could not find service|no such (?:process|file)|service[^\n]*not found|not found[^\n]*service|not loaded|does not exist/i.test(output)
+        || (result.code === 113 && /\bbad request\b/i.test(output));
+}
+function bootoutAccepted(result) {
+    return result.code === 0 || isLaunchdServiceAbsent(result);
+}
 export function isUnloadableLaunchdKickstartError(text) {
     const normalized = String(text || '').toLowerCase();
     return normalized.includes('could not find service')
@@ -170,8 +305,16 @@ export async function removeLaunchAgent(paths, env) {
     const warnings = [];
     const blockers = [];
     const launchctl = env.SKS_MENUBAR_LAUNCHCTL || await which('launchctl').catch(() => null) || '/bin/launchctl';
-    await runProcess(launchctl, ['bootout', launchServiceName()], { timeoutMs: 3_000, maxOutputBytes: 8 * 1024 }).catch(() => undefined);
-    await terminateExistingMenuBarProcess(paths.executable_path);
+    const stopped = await stopMenuBarForReplacement({
+        launchctl,
+        paths,
+        executablePaths: [paths.executable_path],
+        env
+    });
+    if (!stopped.ok)
+        blockers.push(stopped.error || 'menubar_process_stop_failed');
+    if (blockers.length > 0)
+        return { actions, warnings, blockers };
     await fs.rm(paths.launch_agent_path, { force: true }).catch((error) => blockers.push(`remove_launch_agent_failed:${String(error)}`));
     await fs.rm(paths.install_dir, { recursive: true, force: true }).catch((error) => blockers.push(`remove_install_dir_failed:${String(error)}`));
     actions.push(`removed ${paths.launch_agent_path}`, `removed ${paths.install_dir}`);
@@ -182,36 +325,7 @@ export async function removeLaunchAgent(paths, env) {
     return { actions, warnings, blockers };
 }
 export async function isMenuBarProcessRunning(executablePath, env = process.env) {
-    const injectedPgrep = env.SKS_MENUBAR_TEST_PROCESS_TOOLS === '1'
-        ? env.SKS_MENUBAR_PGREP
-        : null;
-    const pgrep = injectedPgrep
-        || (await exists('/usr/bin/pgrep') ? '/usr/bin/pgrep' : null);
-    if (!pgrep)
-        return false;
-    const uid = typeof process.getuid === 'function' ? process.getuid() : null;
-    const args = [
-        ...(uid === null ? [] : ['-U', String(uid)]),
-        '-f',
-        '-x',
-        `^${posixExtendedRegexLiteral(path.resolve(executablePath))}$`
-    ];
-    const result = await runProcess(pgrep, args, { timeoutMs: 2_000, maxOutputBytes: 8 * 1024 }).catch(() => ({ code: 1 }));
-    return result.code === 0;
-}
-async function terminateExistingMenuBarProcess(executablePath) {
-    if (!(await exists(executablePath)))
-        return;
-    if (!await exists('/usr/bin/pkill'))
-        return;
-    const uid = typeof process.getuid === 'function' ? process.getuid() : null;
-    const args = [
-        ...(uid === null ? [] : ['-U', String(uid)]),
-        '-f',
-        '-x',
-        `^${posixExtendedRegexLiteral(path.resolve(executablePath))}$`
-    ];
-    await runProcess('/usr/bin/pkill', args, { timeoutMs: 3_000, maxOutputBytes: 8 * 1024 }).catch(() => undefined);
+    return (await exactMenuBarProcessIds([executablePath], env)).length > 0;
 }
 export function launchDomain() {
     const uid = typeof process.getuid === 'function' ? process.getuid() : null;
@@ -257,6 +371,74 @@ async function waitForMenuBarProcessRunning(executablePath, env) {
         await delay(Math.min(intervalMs, remainingMs));
     }
 }
+export async function inspectRunningMenuBarProcess(paths, launchdPid, env = process.env) {
+    const state = await readJson(paths.runtime_state_path, null);
+    if (!state || state.schema !== 'sks.menubar-runtime-state.v1') {
+        return {
+            checked: true, ok: false, pid: null, package_version: null, build_version: null,
+            executable_path: null, started_at: null, source: 'none', error: 'runtime_state_missing'
+        };
+    }
+    const pid = Number.isInteger(state.pid) && state.pid > 0 ? Number(state.pid) : null;
+    const executablePath = typeof state.executable_path === 'string' ? path.resolve(state.executable_path) : null;
+    const expectedExecutable = path.resolve(paths.executable_path);
+    const exactPath = executablePath === expectedExecutable;
+    const pidMatches = launchdPid === null || pid === launchdPid;
+    const runningPids = exactPath ? await exactMenuBarProcessIds([expectedExecutable], env) : [];
+    const running = pid !== null && runningPids.includes(pid);
+    const singleton = runningPids.length === 1;
+    const ok = Boolean(pid && pidMatches && running && singleton && typeof state.package_version === 'string');
+    return {
+        checked: true,
+        ok,
+        pid,
+        package_version: typeof state.package_version === 'string' ? state.package_version : null,
+        build_version: typeof state.build_version === 'string' ? state.build_version : null,
+        executable_path: executablePath,
+        started_at: typeof state.started_at === 'string' ? state.started_at : null,
+        source: 'runtime-state',
+        error: ok
+            ? null
+            : !exactPath
+                ? 'runtime_executable_path_mismatch'
+                : !pidMatches
+                    ? 'runtime_pid_mismatch'
+                    : !singleton && runningPids.length > 1
+                        ? `multiple_menubar_processes:${runningPids.join(',')}`
+                        : !running
+                            ? 'runtime_process_not_running'
+                            : 'runtime_state_invalid'
+    };
+}
+export async function waitForRunningMenuBarVersion(paths, expectedVersion, expectedPid, env = process.env) {
+    const timeout = timeoutFromEnv(env, 'SKS_MENUBAR_VERSION_PROBE_TIMEOUT_MS', 5_000);
+    const interval = timeoutFromEnv(env, 'SKS_MENUBAR_VERSION_PROBE_INTERVAL_MS', 100);
+    const deadline = Date.now() + timeout;
+    let runtime = await inspectRunningMenuBarProcess(paths, expectedPid, env);
+    while ((!runtime.ok || runtime.package_version !== expectedVersion) && Date.now() < deadline) {
+        await delay(Math.min(interval, Math.max(1, deadline - Date.now())));
+        runtime = await inspectRunningMenuBarProcess(paths, expectedPid, env);
+    }
+    const ok = runtime.ok && runtime.package_version === expectedVersion;
+    const probe = {
+        schema: 'sks.menubar-version-probe.v1',
+        checked: true,
+        ok,
+        expected_version: expectedVersion,
+        running_version: runtime.package_version,
+        pid: runtime.pid,
+        generated_at: new Date().toISOString(),
+        persisted_path: paths.version_probe_path,
+        error: ok ? null : runtime.ok ? 'menubar_running_version_mismatch' : runtime.error
+    };
+    try {
+        await writeJsonAtomic(paths.version_probe_path, probe, { mode: 0o600 });
+        return probe;
+    }
+    catch {
+        return { ...probe, ok: false, error: 'menubar_version_probe_persist_failed' };
+    }
+}
 async function printLaunchdService(launchctl, service, timeoutMs) {
     const result = await runProcess(launchctl, ['print', service], { timeoutMs, maxOutputBytes: 32 * 1024 })
         .catch((error) => failedProcess(error));
@@ -290,6 +472,46 @@ function errorToken(value) {
 function posixExtendedRegexLiteral(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+async function exactMenuBarProcessIds(executablePaths, env = process.env) {
+    const pgrep = await processTool(env, 'SKS_MENUBAR_PGREP', '/usr/bin/pgrep');
+    if (!pgrep || executablePaths.length === 0)
+        return [];
+    const found = new Set();
+    const result = await runProcess(pgrep, exactProcessArguments(executablePaths), {
+        timeoutMs: 2_000,
+        maxOutputBytes: 8 * 1024
+    }).catch(() => ({ code: 1, stdout: '' }));
+    if (result.code === 0) {
+        for (const line of String(result.stdout || '').split(/\r?\n/)) {
+            const pid = Number(line.trim());
+            if (Number.isInteger(pid) && pid > 0)
+                found.add(pid);
+        }
+        if (!String(result.stdout || '').trim())
+            found.add(-1);
+    }
+    return [...found].sort((a, b) => a - b);
+}
+function exactProcessArguments(executablePaths) {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+    const alternatives = executablePaths
+        .map((executablePath) => posixExtendedRegexLiteral(path.resolve(executablePath)));
+    const pattern = alternatives.length === 1
+        ? `^${alternatives[0]}$`
+        : `^(${alternatives.join('|')})$`;
+    return [
+        ...(uid === null ? [] : ['-U', String(uid)]),
+        '-f',
+        '-x',
+        pattern
+    ];
+}
+async function processTool(env, key, fallback) {
+    const injected = env?.SKS_MENUBAR_TEST_PROCESS_TOOLS === '1' ? env[key] : null;
+    if (injected)
+        return injected;
+    return fs.access(fallback).then(() => fallback).catch(() => null);
+}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/core/codex-app/menubar/paths.js

@@ -25,6 +25,9 @@ export function sksMenuBarPaths(homeInput, rootInput) {
         staging_action_script_path: path.join(installDir, 'sks-menubar-action.sh.staging'),
         previous_action_script_path: path.join(installDir, 'sks-menubar-action.sh.previous'),
         build_stamp_path: path.join(installDir, 'build-stamp.json'),
+        runtime_state_path: path.join(installDir, 'runtime-state.json'),
+        version_probe_path: path.join(installDir, 'menubar-version-probe.json'),
+        duplicate_receipts_dir: path.join(installDir, 'receipts', 'project-duplicates'),
         staging_build_stamp_path: path.join(installDir, 'build-stamp.json.staging'),
         previous_build_stamp_path: path.join(installDir, 'build-stamp.json.previous'),
         config_path: path.join(installDir, 'config.json'),

package/dist/core/codex-app/menubar/rollback.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { readJson, sha256, which } from '../../fsx.js';
 import { applyMenuBarGenerationTransaction, commitMenuBarGenerationTransaction, installGenerationPairs, MenuBarGenerationTransactionError, recoverMenuBarGenerationTransaction, rollbackGenerationPairs } from './generation-transaction.js';
-import { launchMenuBar } from './launch-agent.js';
+import { launchMenuBar, stopMenuBarForReplacement } from './launch-agent.js';
 import { sksMenuBarPaths } from './paths.js';
 import { aggregateFileHashes } from './build-stamp.js';
 import { inspectInstalledResources } from './resources.js';
@@ -162,6 +162,14 @@ export async function rollbackSksMenuBar(opts = {}) {
     if (process.platform !== 'darwin') {
         return result('unsupported_platform', true, null, null, null, null, { requested: false, method: 'none', ok: true }, [], ['not_macos']);
     }
+    const launchctl = env.SKS_MENUBAR_LAUNCHCTL || await which('launchctl').catch(() => null) || '/bin/launchctl';
+    const open = env.SKS_MENUBAR_OPEN || await which('open').catch(() => null) || '/usr/bin/open';
+    let replacementStopped = false;
+    if (await existsWithoutFollowingSymlink(paths.install_transaction_path)) {
+        const stopFailure = await stopBeforeReplacement();
+        if (stopFailure)
+            return stopFailure;
+    }
     const installRecovery = await recoverMenuBarGenerationTransaction({
         purpose: 'install',
         journalPath: paths.install_transaction_path,
@@ -189,14 +197,24 @@ export async function rollbackSksMenuBar(opts = {}) {
         if (opts.launch === false || env.SKS_SKIP_SKS_MENUBAR_LAUNCH === '1') {
             return result('rolled_back_launch_skipped', true, restored.package_version, null, null, restored, { requested: false, method: 'skipped', ok: true }, [], warnings);
         }
-        const launchctl = env.SKS_MENUBAR_LAUNCHCTL || await which('launchctl').catch(() => null) || '/bin/launchctl';
-        const open = env.SKS_MENUBAR_OPEN || await which('open').catch(() => null) || '/usr/bin/open';
-        const launch = await launchMenuBar({ launchctl, open, paths, env });
+        const launch = await launchMenuBar({
+            launchctl,
+            open,
+            paths,
+            env,
+            alreadyStopped: replacementStopped,
+            ...(restored.package_version ? { expectedVersion: restored.package_version } : {})
+        });
         return result(launch.ok ? 'rolled_back' : launch.terminal_uncertain ? 'terminal_uncertain' : 'failed', launch.ok, restored.package_version, null, null, restored, launch, launch.ok ? [] : [launch.terminal_uncertain ? 'menubar_rollback_launch_terminal_uncertain' : 'menubar_rollback_launch_failed'], warnings);
     }
     if (installRecovery.status === 'completed_commit')
         actions.push('completed interrupted committed Menu Bar install cleanup');
     const rollbackPairs = rollbackGenerationPairs(paths);
+    if (await existsWithoutFollowingSymlink(paths.rollback_transaction_path)) {
+        const stopFailure = await stopBeforeReplacement();
+        if (stopFailure)
+            return stopFailure;
+    }
     const rollbackRecovery = await recoverMenuBarGenerationTransaction({
         purpose: 'rollback', journalPath: paths.rollback_transaction_path, pairs: rollbackPairs, env
     });
@@ -219,6 +237,9 @@ export async function rollbackSksMenuBar(opts = {}) {
     if (!verificationBefore.ok) {
         return result('failed', false, verificationBefore.package_version, replacedStamp?.package_version || null, verificationBefore, null, { requested: false, method: 'none', ok: false, error: 'rollback_candidate_invalid' }, verificationBefore.blockers, warnings);
     }
+    const stopFailure = await stopBeforeReplacement();
+    if (stopFailure)
+        return stopFailure;
     try {
         transaction = await applyMenuBarGenerationTransaction({
             purpose: 'rollback', journalPath: paths.rollback_transaction_path, pairs: rollbackPairs, env
@@ -268,9 +289,14 @@ export async function rollbackSksMenuBar(opts = {}) {
     if (opts.launch === false || env.SKS_SKIP_SKS_MENUBAR_LAUNCH === '1') {
         return result('rolled_back_launch_skipped', true, verificationBefore.package_version, replacedStamp?.package_version || null, verificationBefore, verificationAfter, { requested: false, method: 'skipped', ok: true }, [], warnings);
     }
-    const launchctl = env.SKS_MENUBAR_LAUNCHCTL || await which('launchctl').catch(() => null) || '/bin/launchctl';
-    const open = env.SKS_MENUBAR_OPEN || await which('open').catch(() => null) || '/usr/bin/open';
-    const launch = await launchMenuBar({ launchctl, open, paths, env });
+    const launch = await launchMenuBar({
+        launchctl,
+        open,
+        paths,
+        env,
+        alreadyStopped: replacementStopped,
+        ...(verificationBefore.package_version ? { expectedVersion: verificationBefore.package_version } : {})
+    });
     if (!launch.ok) {
         return result(launch.terminal_uncertain ? 'terminal_uncertain' : 'failed', false, verificationBefore.package_version, replacedStamp?.package_version || null, verificationBefore, verificationAfter, launch, [launch.terminal_uncertain ? 'menubar_rollback_launch_terminal_uncertain' : 'menubar_rollback_launch_failed'], warnings);
     }
@@ -278,6 +304,28 @@ export async function rollbackSksMenuBar(opts = {}) {
         ? 'launchctl kickstart timed out; launchctl print verified the restored service is running'
         : 'launchctl restarted the restored Menu Bar service');
     return result('rolled_back', true, verificationBefore.package_version, replacedStamp?.package_version || null, verificationBefore, verificationAfter, launch, [], warnings);
+    async function stopBeforeReplacement() {
+        if (replacementStopped)
+            return null;
+        const stopped = await stopMenuBarForReplacement({
+            launchctl,
+            paths,
+            executablePaths: [paths.executable_path],
+            env
+        });
+        if (!stopped.ok) {
+            return result(stopped.timed_out ? 'terminal_uncertain' : 'failed', false, null, null, null, null, {
+                requested: false,
+                method: 'none',
+                ok: false,
+                terminal_uncertain: stopped.timed_out,
+                error: stopped.error || 'menubar_rollback_stop_failed'
+            }, [stopped.error || 'menubar_rollback_stop_failed'], warnings);
+        }
+        replacementStopped = true;
+        actions.push('booted out Menu Bar and verified process termination before journaled rollback replacement');
+        return null;
+    }
     function result(status, ok, previousVersion, replacedVersion, before, after, launch, blockers, resultWarnings) {
         return {
             schema: 'sks.menubar-rollback.v1',