diff --git a/codex-rs/app-server-daemon/Cargo.toml b/codex-rs/app-server-daemon/Cargo.toml
index e00b75ff67..3c98b42f68 100644
--- a/codex-rs/app-server-daemon/Cargo.toml
+++ b/codex-rs/app-server-daemon/Cargo.toml
@@ -33,12 +33,12 @@ tokio = { workspace = true, features = [
     "signal",
     "time",
 ] }
+tempfile = { workspace = true }
 tokio-tungstenite = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = { workspace = true }
-tempfile = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { version = "0.52", features = ["Win32_Foundation", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_JobObjects", "Win32_Security", "Win32_Security_Authorization", "Win32_System_Threading"] }
diff --git a/codex-rs/app-server-daemon/src/backend/windows.rs b/codex-rs/app-server-daemon/src/backend/windows.rs
index 1d2b91eaf5..157bf3343a 100644
--- a/codex-rs/app-server-daemon/src/backend/windows.rs
+++ b/codex-rs/app-server-daemon/src/backend/windows.rs
@@ -1,6 +1,7 @@
 //! Windows process identity and file locks. Keep a process handle across shutdown
 //! so PID reuse can never redirect forced termination to a different process.
 //! Managed servers must not elevate ordinary clients sharing the account's socket.
+//! Installer jobs contain extraction processes when an update is cancelled.
 
 use std::io;
 use std::os::windows::io::AsRawHandle;
@@ -244,6 +245,18 @@ pub(crate) fn try_lock_file(file: &tokio::fs::File) -> Result<bool> {
 // Keep installer descendants bounded by the updater's lifetime, while allowing
 // app-server launches and successor updaters to break away from this job.
 pub(crate) fn updater_job() -> Result<OwnedHandle> {
+    process_job(unsafe { GetCurrentProcess() })
+}
+
+/// Called before writing the installer script, while PowerShell is waiting on stdin.
+pub(crate) fn installer_job(child: &tokio::process::Child) -> Result<OwnedHandle> {
+    let process = child
+        .raw_handle()
+        .context("installer process handle is unavailable")?;
+    process_job(process as isize)
+}
+
+fn process_job(process: isize) -> Result<OwnedHandle> {
     let job = unsafe { CreateJobObjectW(std::ptr::null(), std::ptr::null()) };
     if job == 0 {
         return Err(io::Error::last_os_error()).context("failed to create updater job");
@@ -260,7 +273,7 @@ pub(crate) fn updater_job() -> Result<OwnedHandle> {
             std::mem::size_of_val(&limits) as u32,
         )
     } == 0
-        || unsafe { AssignProcessToJobObject(job, GetCurrentProcess()) } == 0
+        || unsafe { AssignProcessToJobObject(job, process) } == 0
     {
         return Err(io::Error::last_os_error())
             .context("failed to contain updater installer processes");
diff --git a/codex-rs/app-server-daemon/src/install_lock.rs b/codex-rs/app-server-daemon/src/install_lock.rs
new file mode 100644
index 0000000000..8a9d50e06b
--- /dev/null
+++ b/codex-rs/app-server-daemon/src/install_lock.rs
@@ -0,0 +1,143 @@
+//! Coordinates package selection with the shell and PowerShell installers.
+
+use anyhow::Context;
+use anyhow::Result;
+use anyhow::anyhow;
+use std::fs::OpenOptions;
+use std::path::Path;
+use std::time::Duration;
+use tokio::time::sleep;
+
+pub(crate) struct InstallLock {
+    _file: Option<tokio::fs::File>,
+    directory: Option<std::path::PathBuf>,
+    _directory_owner: Option<tempfile::TempDir>,
+}
+
+impl Drop for InstallLock {
+    fn drop(&mut self) {
+        if let Some(directory) = &self.directory {
+            let _ = std::fs::remove_file(directory);
+        }
+    }
+}
+
+pub(crate) async fn acquire_install_lock(root: &Path) -> Result<InstallLock> {
+    let lock = root.join("install.lock");
+    let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
+    #[cfg(unix)]
+    let use_lockf = {
+        // Match the installer so both processes coordinate on the same lock.
+        let choice = tokio::process::Command::new("/bin/sh")
+            .args(["-c", if cfg!(target_os = "macos") {
+                "if command -v lockf >/dev/null 2>&1; then exit 0; elif command -v flock >/dev/null 2>&1; then exit 1; else exit 2; fi"
+            } else {
+                "if command -v flock >/dev/null 2>&1; then exit 1; else exit 2; fi"
+            }])
+            .status().await?;
+        match choice.code() {
+            Some(0) => true,
+            Some(1) => false,
+            Some(2) => {
+                let directory = root.join("install.lock.d");
+                // Publish complete metadata atomically. Older shell installers
+                // immediately remove an empty lock directory as stale.
+                let owner = tempfile::Builder::new()
+                    .prefix("install-lock-")
+                    .tempdir_in(root)?;
+                std::fs::write(owner.path().join("pid"), std::process::id().to_string())?;
+                let now = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)?
+                    .as_secs();
+                std::fs::write(owner.path().join("started_at"), now.to_string())?;
+                loop {
+                    match std::os::unix::fs::symlink(owner.path(), &directory) {
+                        Ok(()) => {
+                            return Ok(InstallLock {
+                                _file: None,
+                                directory: Some(directory),
+                                _directory_owner: Some(owner),
+                            });
+                        }
+                        Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {}
+                        Err(error) => {
+                            return Err(error)
+                                .context("failed to acquire daemon installer directory lock");
+                        }
+                    }
+                    let pid = std::fs::read_to_string(directory.join("pid"))
+                        .ok()
+                        .and_then(|pid| pid.trim().parse::<i32>().ok())
+                        .filter(|pid| *pid > 0);
+                    let dead = pid.is_none_or(|pid| unsafe { libc::kill(pid, 0) } != 0
+                        && std::io::Error::last_os_error().raw_os_error() == Some(libc::ESRCH));
+                    let age = std::fs::metadata(&directory)
+                        .and_then(|metadata| metadata.modified())
+                        .ok()
+                        .and_then(|modified| modified.elapsed().ok())
+                        .unwrap_or_default();
+                    // Allow the creator time to publish its PID; match the installer's
+                    // ten-minute stale-lock grace instead of stealing an active lock.
+                    if dead && age >= Duration::from_secs(600) {
+                        std::fs::remove_dir_all(&directory)?;
+                        continue;
+                    }
+                    anyhow::ensure!(
+                        tokio::time::Instant::now() < deadline,
+                        "timed out waiting for daemon installer lock {}",
+                        directory.display()
+                    );
+                    sleep(Duration::from_millis(50)).await;
+                }
+            }
+            _ => return Err(anyhow!("failed to detect daemon installer lock tools")),
+        }
+    };
+    let mut options = OpenOptions::new();
+    options.create(true).truncate(false).write(true);
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.share_mode(0);
+    }
+    loop {
+        let acquired = options.open(&lock);
+        #[cfg(unix)]
+        let acquired = acquired.and_then(|file| {
+            {
+                use std::os::fd::AsRawFd;
+                let result = if use_lockf {
+                    unsafe { libc::lockf(file.as_raw_fd(), libc::F_TLOCK, 0) }
+                } else {
+                    unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) }
+                };
+                if result != 0 {
+                    return Err(std::io::Error::last_os_error());
+                }
+            }
+            Ok(file)
+        });
+        match acquired {
+            Ok(file) => {
+                return Ok(InstallLock {
+                    _file: Some(tokio::fs::File::from_std(file)),
+                    directory: None,
+                    _directory_owner: None,
+                });
+            }
+            Err(error)
+                if error.kind() == std::io::ErrorKind::WouldBlock
+                    || cfg!(windows)
+                        && (error.raw_os_error() == Some(32)
+                            || error.kind() == std::io::ErrorKind::PermissionDenied) => {}
+            Err(error) => return Err(error).context("failed to acquire daemon installer lock"),
+        }
+        if tokio::time::Instant::now() >= deadline {
+            return Err(anyhow!(
+                "timed out waiting for daemon installer lock {}",
+                lock.display()
+            ));
+        }
+        sleep(Duration::from_millis(50)).await;
+    }
+}
diff --git a/codex-rs/app-server-daemon/src/lib.rs b/codex-rs/app-server-daemon/src/lib.rs
index ccb1be9717..ee821a3876 100644
--- a/codex-rs/app-server-daemon/src/lib.rs
+++ b/codex-rs/app-server-daemon/src/lib.rs
@@ -4,6 +4,7 @@ mod backend;
 #[cfg(windows)]
 use backend::windows::try_lock_file;
 mod client;
+mod install_lock;
 mod managed_install;
 mod remote_control_client;
 mod settings;
@@ -36,8 +37,10 @@ const START_TIMEOUT: Duration = Duration::from_secs(10);
 // Leave room for the longest graceful stop, forced-exit check, and restart.
 const OPERATION_LOCK_TIMEOUT: Duration =
     Duration::from_secs(MAX_SHUTDOWN_GRACE_SECONDS as u64 + 75);
-const PID_FILE_NAME: &str = "app-server.pid";
-const UPDATE_PID_FILE_NAME: &str = "app-server-updater.pid";
+const LEGACY_PID_FILE_NAME: &str = "app-server.pid";
+const LEGACY_UPDATE_PID_FILE_NAME: &str = "app-server-updater.pid";
+const DAEMON_PID_FILE_NAME: &str = "daemon.pid";
+const DAEMON_UPDATE_PID_FILE_NAME: &str = "daemon-updater.pid";
 const OPERATION_LOCK_FILE_NAME: &str = "daemon.lock";
 const SETTINGS_FILE_NAME: &str = "settings.json";
 const STATE_DIR_NAME: &str = "app-server-daemon";
@@ -270,11 +273,13 @@ pub async fn run_pid_update_loop(
     update_loop::run(http_client_factory).await
 }
 
-pub async fn update() -> Result<UpdateOutput> {
+pub async fn update(
+    http_client_factory: codex_http_client::HttpClientFactory,
+) -> Result<UpdateOutput> {
     ensure_supported_platform()?;
     #[cfg(windows)]
     backend::windows::ensure_not_elevated()?;
-    update_loop::request_manual_update(&Daemon::from_environment()?).await
+    update_loop::request_manual_update(&Daemon::from_environment()?, http_client_factory).await
 }
 
 #[cfg(any(unix, windows))]
@@ -289,6 +294,7 @@ fn ensure_supported_platform() -> Result<()> {
     ))
 }
 
+#[derive(Clone)]
 struct Daemon {
     socket_path: PathBuf,
     pid_file: PathBuf,
@@ -305,13 +311,21 @@ impl Daemon {
             .as_path()
             .to_path_buf();
         let state_dir = codex_home.as_path().join(STATE_DIR_NAME);
+        let managed_codex_bin = managed_codex_bin(codex_home.as_path());
+        // Old CLIs must not mistake a daemon-owned installation for their backend.
+        let (pid_file, update_pid_file) =
+            if managed_codex_bin.starts_with(codex_home.as_path().join("packages/standalone")) {
+                (LEGACY_PID_FILE_NAME, LEGACY_UPDATE_PID_FILE_NAME)
+            } else {
+                (DAEMON_PID_FILE_NAME, DAEMON_UPDATE_PID_FILE_NAME)
+            };
         Ok(Self {
             socket_path,
-            pid_file: state_dir.join(PID_FILE_NAME),
-            update_pid_file: state_dir.join(UPDATE_PID_FILE_NAME),
+            pid_file: state_dir.join(pid_file),
+            update_pid_file: state_dir.join(update_pid_file),
             operation_lock_file: state_dir.join(OPERATION_LOCK_FILE_NAME),
             settings_file: state_dir.join(SETTINGS_FILE_NAME),
-            managed_codex_bin: managed_codex_bin(codex_home.as_path()),
+            managed_codex_bin,
         })
     }
 
@@ -324,25 +338,45 @@ impl Daemon {
         ))
     }
 
+    // Call only after taking the operation lock: an explicit update may have
+    // migrated the package and PID namespace while this command was waiting.
+    fn current_installation(&self) -> Result<Self> {
+        let managed_codex_bin = self.current_managed_codex_bin()?;
+        let home = self
+            .settings_file
+            .parent()
+            .and_then(Path::parent)
+            .context("daemon settings path has no Codex home")?;
+        let (pid, updater) = if managed_codex_bin.starts_with(home.join("packages/standalone")) {
+            (LEGACY_PID_FILE_NAME, LEGACY_UPDATE_PID_FILE_NAME)
+        } else {
+            (DAEMON_PID_FILE_NAME, DAEMON_UPDATE_PID_FILE_NAME)
+        };
+        Ok(Self {
+            managed_codex_bin,
+            pid_file: self.pid_file.with_file_name(pid),
+            update_pid_file: self.update_pid_file.with_file_name(updater),
+            ..self.clone()
+        })
+    }
+
     async fn run(&self, command: LifecycleCommand) -> Result<LifecycleOutput> {
+        if command == LifecycleCommand::Version {
+            return self.version().await;
+        }
+        let _operation_lock = self.acquire_operation_lock().await?;
+        let selected = self.current_installation()?;
         match command {
-            LifecycleCommand::Start => {
-                let _operation_lock = self.acquire_operation_lock().await?;
-                self.start().await
-            }
-            LifecycleCommand::Restart => {
-                let _operation_lock = self.acquire_operation_lock().await?;
-                self.restart().await
-            }
+            LifecycleCommand::Start => selected.start().await,
+            LifecycleCommand::Restart => selected.restart().await,
             LifecycleCommand::Stop => {
-                let _operation_lock = self.acquire_operation_lock().await?;
-                let output = self.stop().await?;
-                if let Err(err) = thread_recovery::discard_pending(self) {
+                let output = selected.stop().await?;
+                if let Err(err) = thread_recovery::discard_pending(&selected) {
                     eprintln!("warning: failed to clear saved threads after daemon stop: {err}");
                 }
                 Ok(output)
             }
-            LifecycleCommand::Version => self.version().await,
+            LifecycleCommand::Version => unreachable!(),
         }
     }
 
@@ -597,21 +631,22 @@ impl Daemon {
 
     async fn bootstrap(&self, options: BootstrapOptions) -> Result<BootstrapOutput> {
         let _operation_lock = self.acquire_operation_lock().await?;
-        self.bootstrap_locked(options).await
+        self.current_installation()?.bootstrap_locked(options).await
     }
 
     async fn ensure_remote_control_started(&self) -> Result<RemoteControlStartOutput> {
         let _operation_lock = self.acquire_operation_lock().await?;
-        let settings = self.load_settings().await?;
-        if self.is_bootstrapped(&settings).await? {
-            let _ = self
+        let selected = self.current_installation()?;
+        let settings = selected.load_settings().await?;
+        if selected.is_bootstrapped(&settings).await? {
+            let _ = selected
                 .set_remote_control_locked(RemoteControlMode::Enabled)
                 .await?;
-            let output = self.start().await?;
+            let output = selected.start().await?;
             return Ok(RemoteControlStartOutput::Start(output));
         }
 
-        let output = self
+        let output = selected
             .bootstrap_locked(BootstrapOptions {
                 remote_control_enabled: true,
             })
@@ -631,7 +666,9 @@ impl Daemon {
 
     async fn set_remote_control(&self, mode: RemoteControlMode) -> Result<RemoteControlOutput> {
         let _operation_lock = self.acquire_operation_lock().await?;
-        self.set_remote_control_locked(mode).await
+        self.current_installation()?
+            .set_remote_control_locked(mode)
+            .await
     }
 
     async fn set_remote_control_locked(
@@ -851,7 +888,8 @@ impl Daemon {
             .parent()
             .and_then(Path::parent)
             .is_some_and(|home| {
-                home.join("packages/standalone/auto-update-version")
+                managed_install::package_root(home)
+                    .join("auto-update-version")
                     .is_file()
             })
     }
@@ -917,8 +955,7 @@ impl Daemon {
     }
 
     fn manual_update_socket_path(&self) -> PathBuf {
-        self.update_pid_file
-            .with_file_name("app-server-updater.sock")
+        self.update_pid_file.with_extension("sock")
     }
 
     async fn load_settings(&self) -> Result<DaemonSettings> {
@@ -1188,6 +1225,41 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn waiting_lifecycle_command_uses_migrated_installation() {
+        let home = TempDir::new().expect("home");
+        let state = home.path().join("app-server-daemon");
+        let legacy = home.path().join("packages/standalone/current");
+        std::fs::create_dir_all(&legacy).expect("legacy selection");
+        let daemon = Daemon {
+            socket_path: home.path().join("server.sock"),
+            pid_file: state.join(super::LEGACY_PID_FILE_NAME),
+            update_pid_file: state.join(super::LEGACY_UPDATE_PID_FILE_NAME),
+            operation_lock_file: state.join("daemon.lock"),
+            settings_file: state.join("settings.json"),
+            managed_codex_bin: super::managed_codex_bin(home.path()),
+        };
+        let lock = daemon.acquire_operation_lock().await.expect("lock");
+        let stop = daemon.run(super::LifecycleCommand::Stop);
+        tokio::pin!(stop);
+        assert!(
+            tokio::time::timeout(std::time::Duration::from_millis(20), &mut stop)
+                .await
+                .is_err()
+        );
+        std::fs::create_dir_all(home.path().join("packages/app-server-daemon/current"))
+            .expect("migrate selection");
+        drop(lock);
+        let output = stop.await.expect("stop");
+        assert_eq!(
+            (output.status, output.managed_codex_path),
+            (
+                LifecycleStatus::NotRunning,
+                super::managed_codex_bin(home.path())
+            )
+        );
+    }
+
     #[tokio::test]
     async fn stop_creates_missing_home_parent() {
         let temp = TempDir::new().expect("temp dir");
diff --git a/codex-rs/app-server-daemon/src/managed_install.rs b/codex-rs/app-server-daemon/src/managed_install.rs
index b7b57f7f68..099c1b71c9 100644
--- a/codex-rs/app-server-daemon/src/managed_install.rs
+++ b/codex-rs/app-server-daemon/src/managed_install.rs
@@ -14,19 +14,63 @@ use tokio::fs;
 use tokio::process::Command;
 use tokio::time::timeout;
 
-/// Returns the packaged executable when present, otherwise an existing legacy executable.
-/// If neither exists, returns the expected packaged path on Windows and preserves the
-/// historical legacy fallback on Unix. This is path selection, not existence validation:
-/// launch operations reject a missing executable separately, while commands such as
-/// stop can still run after the managed install has been removed.
+/// Dedicated daemon packages take precedence over standalone installations.
+/// Preserve legacy launch state, including logs left after a daemon is stopped;
+/// settings, installer selections, and lock files alone do not prove a prior launch.
+pub(crate) fn package_root(codex_home: &Path) -> PathBuf {
+    let dedicated = codex_home.join("packages/app-server-daemon");
+    if !matches!(dedicated.join("current").symlink_metadata(),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound)
+    {
+        return dedicated;
+    }
+    let state = codex_home.join("app-server-daemon");
+    for (package, artifacts) in [
+        (
+            "app-server-daemon",
+            [
+                crate::DAEMON_PID_FILE_NAME,
+                "daemon.stderr.log",
+                crate::DAEMON_UPDATE_PID_FILE_NAME,
+                "daemon-updater.stderr.log",
+            ],
+        ),
+        (
+            "standalone",
+            [
+                crate::LEGACY_PID_FILE_NAME,
+                "app-server.stderr.log",
+                crate::LEGACY_UPDATE_PID_FILE_NAME,
+                "app-server-updater.stderr.log",
+            ],
+        ),
+    ] {
+        if artifacts.iter().any(|name| {
+            !matches!(state.join(name).symlink_metadata(),
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound)
+        }) {
+            return codex_home.join("packages").join(package);
+        }
+    }
+    // Retain CLI installs until the next stage adds dedicated package seeding.
+    let standalone = codex_home.join("packages/standalone");
+    if !matches!(standalone.join("current").symlink_metadata(),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound)
+    {
+        return standalone;
+    }
+    dedicated
+}
+
+/// Resolve both packaged and legacy binaries without requiring a valid install.
 pub(crate) fn managed_codex_bin(codex_home: &Path) -> PathBuf {
-    let current = codex_home
-        .join("packages")
-        .join("standalone")
-        .join("current");
+    let root = package_root(codex_home);
+    let current = root.join("current");
     let packaged = current.join("bin").join(managed_codex_file_name());
     let legacy = current.join(managed_codex_file_name());
-    if packaged.is_file() || (cfg!(windows) && !legacy.is_file()) {
+    if packaged.is_file()
+        || !legacy.is_file() && (cfg!(windows) || root.ends_with("app-server-daemon"))
+    {
         packaged
     } else {
         legacy
@@ -35,7 +79,7 @@ pub(crate) fn managed_codex_bin(codex_home: &Path) -> PathBuf {
 
 /// Only latest-channel stable releases may run the public latest-version updater.
 pub(crate) fn is_stable_standalone_release(codex_home: &Path, codex_bin: &Path) -> bool {
-    let standalone = codex_home.join("packages/standalone");
+    let standalone = package_root(codex_home);
     let Ok(releases) = std::fs::canonicalize(standalone.join("releases")) else {
         return false;
     };
@@ -48,9 +92,15 @@ pub(crate) fn is_stable_standalone_release(codex_home: &Path, codex_bin: &Path)
     let Some(release_name) = release.file_name().and_then(|name| name.to_str()) else {
         return false;
     };
+    // GNU packages can seed the new directory; retain legacy updater eligibility.
+    if standalone.ends_with("standalone") && release_name.ends_with("-gnu") {
+        return false;
+    }
     let targets = [
         "aarch64-apple-darwin",
         "x86_64-apple-darwin",
+        "aarch64-unknown-linux-gnu",
+        "x86_64-unknown-linux-gnu",
         "aarch64-unknown-linux-musl",
         "x86_64-unknown-linux-musl",
         "aarch64-pc-windows-msvc",
@@ -74,13 +124,19 @@ pub(crate) fn is_stable_standalone_release(codex_home: &Path, codex_bin: &Path)
 
 /// Older managed binaries can serve app-server requests without owning an updater.
 pub(crate) async fn supports_daemon_update_loop(codex_bin: &Path) -> bool {
+    supports_daemon_command(codex_bin, &["pid-update-loop", "--help"]).await
+}
+
+/// Probe an internal daemon command without running a long-lived process.
+pub(crate) async fn supports_daemon_command(codex_bin: &Path, args: &[&str]) -> bool {
     let mut command = Command::new(codex_bin);
     #[cfg(windows)]
     command.creation_flags(windows_sys::Win32::System::Threading::CREATE_NO_WINDOW);
     timeout(
         Duration::from_secs(5),
         command
-            .args(["app-server", "daemon", "pid-update-loop", "--help"])
+            .args(["app-server", "daemon"])
+            .args(args)
             .stdin(Stdio::null())
             .stdout(Stdio::null())
             .stderr(Stdio::null())
diff --git a/codex-rs/app-server-daemon/src/managed_install_path_tests.rs b/codex-rs/app-server-daemon/src/managed_install_path_tests.rs
index 7e49e80fb8..174c634005 100644
--- a/codex-rs/app-server-daemon/src/managed_install_path_tests.rs
+++ b/codex-rs/app-server-daemon/src/managed_install_path_tests.rs
@@ -5,25 +5,70 @@ fn discovers_package_and_legacy_installs() {
     let home = tempfile::TempDir::new().expect("home");
     let current = home.path().join("packages/standalone/current");
     let legacy = current.join(super::managed_codex_file_name());
-    let expected = if cfg!(windows) {
-        current.join("bin").join("codex.exe")
-    } else {
-        legacy.clone()
-    };
-    assert_eq!(super::managed_codex_bin(home.path()), expected);
+    assert_eq!(
+        super::managed_codex_bin(home.path()),
+        home.path()
+            .join("packages/app-server-daemon/current/bin")
+            .join(super::managed_codex_file_name())
+    );
     std::fs::create_dir_all(&current).expect("current directory");
     std::fs::write(&legacy, b"legacy").expect("legacy executable");
+    let state = home.path().join("app-server-daemon");
+    std::fs::create_dir(&state).unwrap();
+    for name in ["settings.json", "daemon.lock", "app-server.pid.lock"] {
+        std::fs::write(state.join(name), b"").unwrap();
+    }
+    // A CLI install and a previous stop/status operation do not establish ownership.
+    assert_eq!(
+        super::package_root(home.path()),
+        home.path().join("packages/standalone")
+    );
+    std::fs::write(state.join("app-server.stderr.log"), b"").unwrap();
     assert_eq!(super::managed_codex_bin(home.path()), legacy);
     let packaged = current.join("bin").join(super::managed_codex_file_name());
     std::fs::create_dir(current.join("bin")).expect("bin directory");
     std::fs::write(&packaged, b"packaged").expect("packaged executable");
     assert_eq!(super::managed_codex_bin(home.path()), packaged);
+
+    std::fs::remove_dir_all(home.path().join("packages/standalone")).unwrap();
+    assert_eq!(
+        super::package_root(home.path()),
+        home.path().join("packages/standalone")
+    );
+    std::fs::remove_file(state.join("app-server.stderr.log")).unwrap();
+    std::fs::write(state.join("app-server.pid"), b"running daemon").unwrap();
+    assert_eq!(
+        super::package_root(home.path()),
+        home.path().join("packages/standalone")
+    );
+
+    std::fs::write(state.join("daemon.pid"), b"running dedicated daemon").unwrap();
+    assert_eq!(
+        super::package_root(home.path()),
+        home.path().join("packages/app-server-daemon")
+    );
+    std::fs::remove_file(state.join("daemon.pid")).unwrap();
+    std::fs::write(state.join("daemon.stderr.log"), b"").unwrap();
+    assert_eq!(
+        super::package_root(home.path()),
+        home.path().join("packages/app-server-daemon")
+    );
+
+    #[cfg(unix)]
+    {
+        let dedicated = home.path().join("packages/app-server-daemon");
+        std::fs::write(&dedicated, b"not a directory").expect("unreadable selection");
+        assert_eq!(super::package_root(home.path()), dedicated);
+    }
 }
 
 #[cfg(unix)]
 #[test]
 fn updater_only_runs_for_stable_installer_owned_releases() {
     let home = tempfile::TempDir::new().expect("home");
+    let state = home.path().join("app-server-daemon");
+    std::fs::create_dir(&state).unwrap();
+    std::fs::write(state.join("app-server.stderr.log"), b"").unwrap();
     let standalone = home.path().join("packages/standalone");
     let current = standalone.join("current");
     let release = standalone.join("releases/0.150.0-aarch64-apple-darwin");
diff --git a/codex-rs/app-server-daemon/src/manual_update.rs b/codex-rs/app-server-daemon/src/manual_update.rs
index 743b6e4e6f..e822e51d52 100644
--- a/codex-rs/app-server-daemon/src/manual_update.rs
+++ b/codex-rs/app-server-daemon/src/manual_update.rs
@@ -126,7 +126,7 @@ pub(crate) async fn request(daemon: &Daemon) -> Result<UpdateOutput> {
 
 const UNSUPPORTED_MESSAGE: &str = "This command requires a CLI-managed daemon and a stable latest-channel standalone install; update this installation with its owning installer.";
 
-async fn unsupported(daemon: &Daemon) -> Result<UpdateOutput> {
+pub(super) async fn unsupported(daemon: &Daemon) -> Result<UpdateOutput> {
     let managed_codex_path = daemon.current_managed_codex_bin()?;
     Ok(UpdateOutput {
         status: UpdateStatus::Unsupported,
diff --git a/codex-rs/app-server-daemon/src/migration.rs b/codex-rs/app-server-daemon/src/migration.rs
new file mode 100644
index 0000000000..e250f6df52
--- /dev/null
+++ b/codex-rs/app-server-daemon/src/migration.rs
@@ -0,0 +1,193 @@
+//! Moves a legacy daemon to its dedicated package only during an explicit update.
+//! Preparation leaves the legacy selection intact; publishing current is the cutover.
+
+use std::path::Path;
+
+use anyhow::Context;
+use anyhow::Result;
+use futures::FutureExt;
+
+use super::InstallerHttp;
+use super::InstallerMode;
+use super::fetch_installer_script;
+use super::run_installer_script;
+use super::selected_release;
+use crate::Daemon;
+use crate::UpdateOutput;
+use crate::UpdateStatus;
+use crate::backend;
+use crate::client;
+use crate::install_lock::acquire_install_lock;
+use crate::managed_install;
+
+pub(super) async fn run(http: &impl InstallerHttp, legacy: &Daemon) -> Result<UpdateOutput> {
+    let _operation_lock = legacy.acquire_operation_lock().await?;
+    let previous = selected_release(legacy)?;
+    anyhow::ensure!(
+        previous.0.ends_with("standalone") && legacy.is_stable_standalone_release()?,
+        "daemon selection changed; retry the update"
+    );
+    let home = previous
+        .0
+        .parent()
+        .and_then(Path::parent)
+        .context("package root has no Codex home")?;
+    let root = home.join("packages/app-server-daemon");
+    let settings = legacy.load_settings().await?;
+    let running = legacy.running_backend_instance(&settings).await?;
+    if running.is_none() && client::probe(&legacy.socket_path).await.is_ok() {
+        return super::manual_update::unsupported(legacy).await;
+    }
+    #[cfg(unix)]
+    let mut terminate = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())?;
+    let cancellation = async {
+        #[cfg(unix)]
+        tokio::select! {
+            _ = terminate.recv() => {},
+            _ = tokio::signal::ctrl_c() => {},
+        }
+        #[cfg(windows)]
+        let _ = tokio::signal::ctrl_c().await;
+        Some(())
+    };
+    let mut cancellation = std::pin::pin!(cancellation);
+
+    let script = fetch_installer_script(http).await?;
+    anyhow::ensure!(
+        script
+            .windows(b"CODEX_INSTALL_DEFER_SELECTION".len())
+            .any(|window| window == b"CODEX_INSTALL_DEFER_SELECTION"),
+        "the published installer does not support daemon migration yet; the legacy installation was left unchanged"
+    );
+    eprintln!("Preparing the daemon update in {}...", root.display());
+    #[cfg(unix)]
+    {
+        if matches!(
+            run_installer_script(
+                &script,
+                InstallerMode::Migration,
+                &root,
+                cancellation.as_mut()
+            )
+            .await?,
+            super::UpdateLoopControl::Stop
+        ) {
+            return Err(std::io::Error::from(std::io::ErrorKind::Interrupted).into());
+        }
+    }
+    #[cfg(windows)]
+    tokio::select! {
+        result = run_installer_script(&script, InstallerMode::Migration, &root) => { result?; },
+        _ = &mut cancellation => return Err(std::io::Error::from(std::io::ErrorKind::Interrupted).into()),
+    }
+
+    let _install_lock = acquire_install_lock(&root).await?;
+    let pending = root.join(".migration-current");
+    let release = pending
+        .canonicalize()
+        .context("installer did not prepare a daemon package")?;
+    let name = release
+        .file_name()
+        .context("prepared release has no name")?;
+    anyhow::ensure!(
+        release.parent() == Some(root.join("releases").canonicalize()?.as_path())
+            && std::fs::read_to_string(root.join("auto-update-version"))? == name.to_string_lossy(),
+        "installer did not prepare a latest-channel daemon package"
+    );
+    let entrypoint = if cfg!(windows) {
+        "bin/codex.exe"
+    } else {
+        "bin/codex"
+    };
+    let binary = release.join(entrypoint);
+    let version = managed_install::managed_codex_version(&binary).await?;
+    anyhow::ensure!(
+        name.to_string_lossy().starts_with(&format!("{version}-")),
+        "prepared daemon version does not match its release"
+    );
+    // An older production updater understands only the legacy package/PID paths.
+    anyhow::ensure!(
+        managed_install::supports_daemon_command(
+            &binary,
+            &["pid-update-loop", "--check-package-ownership"]
+        )
+        .await,
+        "the latest production release does not support daemon migration yet; the legacy daemon was left running"
+    );
+    #[cfg(windows)]
+    backend::windows::ensure_detached_launch(&binary)?;
+    anyhow::ensure!(
+        selected_release(legacy)? == previous,
+        "daemon selection changed; retry the update"
+    );
+    if cancellation.as_mut().now_or_never().is_some() {
+        return Err(std::io::Error::from(std::io::ErrorKind::Interrupted).into());
+    }
+    let cutover = async {
+        backend::pid_update_loop_backend(legacy.backend_paths(&settings))
+            .stop()
+            .await?;
+        anyhow::ensure!(
+            selected_release(legacy)? == previous,
+            "daemon selection changed; retry the update"
+        );
+        if let Some(running) = &running {
+            crate::thread_recovery::discard_pending(legacy)?;
+            running
+                .stop_with_grace(settings.shutdown_grace_seconds)
+                .await?;
+        }
+        std::fs::rename(&pending, root.join("current"))
+            .context("failed to select the new daemon package; retry the update")
+    }
+    .await;
+    if let Err(error) = cutover {
+        if let Err(restore_error) = async {
+            legacy
+                .current_installation()?
+                .ensure_managed_updater(&settings)
+                .await
+        }
+        .await
+        {
+            eprintln!(
+                "warning: failed to restore the legacy updater after migration failed: {restore_error:#}"
+            );
+        }
+        return Err(error);
+    }
+    let selected = Daemon {
+        pid_file: legacy.pid_file.with_file_name(crate::DAEMON_PID_FILE_NAME),
+        update_pid_file: legacy
+            .update_pid_file
+            .with_file_name(crate::DAEMON_UPDATE_PID_FILE_NAME),
+        managed_codex_bin: root.join("current").join(entrypoint),
+        ..legacy.clone()
+    };
+    let running_version = if running.is_some() {
+        selected.start_managed_backend(&settings).await.context(
+            "daemon migrated but could not start; retry with `codex app-server daemon start`",
+        )?;
+        Some(
+            selected
+                .wait_until_ready()
+                .await
+                .context(
+                    "daemon migrated but is not ready; retry with `codex app-server daemon start`",
+                )?
+                .app_server_version,
+        )
+    } else {
+        None
+    };
+    if let Err(error) = selected.ensure_managed_updater(&settings).await {
+        eprintln!("warning: daemon migrated but its updater could not start: {error:#}");
+    }
+    Ok(UpdateOutput {
+        status: UpdateStatus::Updated,
+        installed_version: Some(version),
+        running_version,
+        managed_codex_path: selected.managed_codex_bin,
+        message: "The daemon was updated and moved to its dedicated package. The legacy CLI package was left unchanged.".to_string(),
+    })
+}
diff --git a/codex-rs/app-server-daemon/src/update_loop.rs b/codex-rs/app-server-daemon/src/update_loop.rs
index 2fe7850df4..4513ce6855 100644
--- a/codex-rs/app-server-daemon/src/update_loop.rs
+++ b/codex-rs/app-server-daemon/src/update_loop.rs
@@ -38,7 +38,27 @@ use crate::settings::UpdaterSettings;
 
 #[path = "manual_update.rs"]
 mod manual_update;
-pub(crate) use manual_update::request as request_manual_update;
+#[path = "migration.rs"]
+mod migration;
+
+pub(crate) async fn request_manual_update(
+    daemon: &Daemon,
+    http_client_factory: HttpClientFactory,
+) -> Result<crate::UpdateOutput> {
+    if daemon
+        .pid_file
+        .file_name()
+        .is_some_and(|name| name == crate::LEGACY_PID_FILE_NAME)
+        && daemon.is_stable_standalone_release()?
+    {
+        let http = RouteAwareClientPool::new_without_request_logging(
+            http_client_factory,
+            ClientRouteClass::Other,
+        );
+        return migration::run(&http, daemon).await;
+    }
+    manual_update::request(daemon).await
+}
 
 const INITIAL_UPDATE_DELAY: Duration = Duration::from_secs(5 * 60);
 const RESTART_RETRY_INTERVAL: Duration = Duration::from_millis(50);
@@ -277,7 +297,11 @@ async fn update_once(
         // latest-channel marker. Retry after the interval instead of exiting.
         return Ok((UpdateLoopControl::Continue, None));
     }
-    let (_codex_home, _, previous_release) = selected_release(daemon)?;
+    let (package_root, _, previous_release) = selected_release(daemon)?;
+    let codex_home = package_root
+        .parent()
+        .and_then(Path::parent)
+        .context("daemon package root has no Codex home")?;
     let script = tokio::select! {
         result = fetch_installer_script(http) => result?,
         _ = terminate.recv() => return Ok((UpdateLoopControl::Stop, None)),
@@ -288,6 +312,14 @@ async fn update_once(
             .any(|window| window == b"CODEX_INSTALL_IF_LATEST"),
         "standalone installer does not support guarded updates"
     );
+    if package_root.ends_with("app-server-daemon") {
+        anyhow::ensure!(
+            script
+                .windows(b"CODEX_INSTALL_DAEMON_ONLY".len())
+                .any(|window| window == b"CODEX_INSTALL_DAEMON_ONLY"),
+            "installer does not support daemon-owned packages"
+        );
+    }
     if trigger == UpdateTrigger::Scheduled
         && !UpdaterSettings::load(&daemon.settings_file)
             .await?
@@ -298,16 +330,26 @@ async fn update_once(
     if release_selection_unstable(daemon, trigger)? {
         return Ok((UpdateLoopControl::Continue, None));
     }
+    anyhow::ensure!(
+        crate::managed_install::package_root(codex_home) == package_root,
+        "daemon package root changed during the update; retry the command"
+    );
     #[cfg(unix)]
     if matches!(
-        run_installer_script(&script, &previous_release, _codex_home, terminate.recv()).await?,
+        run_installer_script(
+            &script,
+            InstallerMode::Update(&previous_release),
+            &package_root,
+            terminate.recv()
+        )
+        .await?,
         UpdateLoopControl::Stop
     ) {
         return Ok((UpdateLoopControl::Stop, None));
     }
     #[cfg(windows)]
     tokio::select! {
-        result = run_installer_script(&script, &previous_release) => { result?; },
+        result = run_installer_script(&script, InstallerMode::Update(&previous_release), &package_root) => { result?; },
         _ = terminate.recv() => return Ok((UpdateLoopControl::Stop, None)),
     }
     if release_selection_unstable(daemon, trigger)? {
@@ -395,19 +437,20 @@ fn release_selection_unstable(daemon: &Daemon, trigger: UpdateTrigger) -> Result
     Ok(true)
 }
 
-fn selected_release(daemon: &Daemon) -> Result<(&Path, std::path::PathBuf, String)> {
+fn selected_release(daemon: &Daemon) -> Result<(std::path::PathBuf, std::path::PathBuf, String)> {
     let home = daemon
         .settings_file
         .parent()
         .and_then(Path::parent)
         .context("daemon settings path has no Codex home")?;
-    let release = std::fs::canonicalize(home.join("packages/standalone/current"))?;
+    let root = crate::managed_install::package_root(home);
+    let release = std::fs::canonicalize(root.join("current"))?;
     let name = release
         .file_name()
         .context("managed release has no name")?
         .to_string_lossy()
         .into_owned();
-    Ok((home, release, name))
+    Ok((root, release, name))
 }
 
 async fn current_updater_identity() -> Result<ExecutableIdentity> {
@@ -429,10 +472,15 @@ pub(crate) fn reexec_managed_updater(managed_codex_bin: &std::path::Path) -> Res
     })
 }
 
+enum InstallerMode<'a> {
+    Update(&'a str),
+    Migration,
+}
+
 async fn run_installer_script(
     script: &[u8],
-    previous_release: &str,
-    #[cfg(unix)] codex_home: &Path,
+    mode: InstallerMode<'_>,
+    package_root: &Path,
     #[cfg(unix)] terminate: impl std::future::Future<Output = Option<()>>,
 ) -> Result<UpdateLoopControl> {
     #[cfg(unix)]
@@ -450,10 +498,30 @@ async fn run_installer_script(
             .kill_on_drop(true);
         command
     };
+    let (guard, previous_release, defer_selection) = match mode {
+        InstallerMode::Update(release) => ("1", release, "0"),
+        InstallerMode::Migration => ("0", "", "1"),
+    };
     let mut child = command
+        .env(
+            "CODEX_HOME",
+            package_root
+                .parent()
+                .and_then(Path::parent)
+                .context("package root has no Codex home")?,
+        )
+        .env("CODEX_INSTALL_DEFER_SELECTION", defer_selection)
+        .env(
+            "CODEX_INSTALL_DAEMON_ONLY",
+            if package_root.ends_with("app-server-daemon") {
+                "1"
+            } else {
+                "0"
+            },
+        )
         .env("CODEX_RELEASE", "latest")
         .env("CODEX_NON_INTERACTIVE", "1")
-        .env("CODEX_INSTALL_IF_LATEST", "1")
+        .env("CODEX_INSTALL_IF_LATEST", guard)
         .env("CODEX_UPDATE_FROM_RELEASE", previous_release)
         .kill_on_drop(true)
         .stdin(Stdio::piped())
@@ -461,6 +529,8 @@ async fn run_installer_script(
         .stderr(Stdio::null())
         .spawn()
         .context("failed to invoke standalone Codex updater")?;
+    #[cfg(windows)]
+    let _installer_job = crate::backend::windows::installer_job(&child)?;
     let mut stdin = child
         .stdin
         .take()
@@ -477,7 +547,7 @@ async fn run_installer_script(
     drop(stdin);
     #[cfg(unix)]
     if write_result.is_none() {
-        cancel_installer(&mut child, codex_home).await;
+        cancel_installer(&mut child, package_root).await;
         return Ok(UpdateLoopControl::Stop);
     }
     write_result
@@ -487,7 +557,7 @@ async fn run_installer_script(
     let status = tokio::select! {
         result = child.wait() => result,
         _ = &mut terminate => {
-            cancel_installer(&mut child, codex_home).await;
+            cancel_installer(&mut child, package_root).await;
             return Ok(UpdateLoopControl::Stop);
         }
     };
@@ -503,7 +573,7 @@ async fn run_installer_script(
 }
 
 #[cfg(unix)]
-async fn cancel_installer(child: &mut tokio::process::Child, codex_home: &Path) {
+async fn cancel_installer(child: &mut tokio::process::Child, package_root: &Path) {
     let Some(pid) = child.id().and_then(|pid| libc::pid_t::try_from(pid).ok()) else {
         return;
     };
@@ -515,7 +585,7 @@ async fn cancel_installer(child: &mut tokio::process::Child, codex_home: &Path)
     unsafe { libc::kill(-pid, libc::SIGKILL) };
     // A forced kill can bypass the shell trap on hosts using the mkdir lock.
     // The lock is ours only if its recorded owner is this still-unreaped shell.
-    let lock = codex_home.join("packages/standalone/install.lock.d");
+    let lock = package_root.join("install.lock.d");
     if std::fs::read_to_string(lock.join("pid")).is_ok_and(|owner| owner.trim() == pid.to_string())
     {
         let _ = std::fs::remove_dir_all(lock);
diff --git a/codex-rs/app-server-daemon/src/update_loop_tests.rs b/codex-rs/app-server-daemon/src/update_loop_tests.rs
index ff2b177b86..2dfd3c40a1 100644
--- a/codex-rs/app-server-daemon/src/update_loop_tests.rs
+++ b/codex-rs/app-server-daemon/src/update_loop_tests.rs
@@ -54,6 +54,135 @@ struct FakeInstallerHttp {
     requested_urls: Mutex<Vec<String>>,
 }
 
+#[cfg(unix)]
+#[tokio::test]
+async fn explicit_update_migrates_running_and_stopped_installations() {
+    for running in [false, true] {
+        let home = TempDir::new().unwrap();
+        let (legacy, release) = manual_update_daemon(&home);
+        let scheduled = FakeInstallerHttp::new(InstallerResponse::Success(
+        b"# CODEX_INSTALL_IF_LATEST\ntest \"$CODEX_INSTALL_DEFER_SELECTION\" = 0 && test \"$CODEX_INSTALL_DAEMON_ONLY\" = 0\n".to_vec(),
+    ));
+        super::update_once(
+            &scheduled,
+            &legacy,
+            &executable_identity(&legacy.managed_codex_bin)
+                .await
+                .unwrap(),
+            &mut test_terminate(),
+            super::UpdateTrigger::Scheduled,
+        )
+        .await
+        .unwrap();
+        assert_eq!(scheduled.requested_urls(), vec![INSTALL_URL.to_string()]);
+        assert_eq!(
+            crate::managed_install::package_root(home.path()),
+            home.path().join("packages/standalone")
+        );
+        let settings = format!(
+            r#"{{"updater":{{"autoUpdateEnabled":{running}}},"remoteControlEnabled":true}}"#
+        );
+        std::fs::write(&legacy.settings_file, &settings).unwrap();
+        let daemon_settings = legacy.load_settings().await.unwrap();
+        let old_backend = crate::backend::pid_backend(legacy.backend_paths(&daemon_settings));
+        let old_updater =
+            crate::backend::pid_update_loop_backend(legacy.backend_paths(&daemon_settings));
+        let server = if running {
+            old_backend.start().await.unwrap();
+            old_updater.start().await.unwrap();
+            Some(test_control_server(&legacy, home.path()).await)
+        } else {
+            None
+        };
+        let legacy_bin = std::fs::read(&legacy.managed_codex_bin).unwrap();
+        let dedicated = home.path().join("packages/app-server-daemon");
+        let old_installer = FakeInstallerHttp::new(InstallerResponse::Success(b"exit 99".to_vec()));
+        assert!(
+            super::migration::run(&old_installer, &legacy)
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("does not support daemon migration")
+        );
+
+        let script = format!(
+            r#"# CODEX_INSTALL_DEFER_SELECTION
+set -eu
+test "$CODEX_INSTALL_DEFER_SELECTION" = 1
+test "$CODEX_INSTALL_DAEMON_ONLY" = 1
+test "$CODEX_INSTALL_IF_LATEST" = 0
+root="$CODEX_HOME/packages/app-server-daemon"
+mkdir -p "$root/releases/{release}/bin"
+printf '#!/bin/sh\nif [ "$1" = --version ]; then echo codex 1.0.0; else exit 2; fi\n' > "$root/releases/{release}/bin/codex"
+chmod +x "$root/releases/{release}/bin/codex"
+ln -sfn 'releases/{release}' "$root/.migration-current"
+printf '{release}' > "$root/auto-update-version"
+"#
+        );
+        let http = FakeInstallerHttp::new(InstallerResponse::Success(script.as_bytes().to_vec()));
+        let error = super::migration::run(&http, &legacy).await.unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("production release does not support daemon migration")
+        );
+        assert!(!dedicated.join("current").exists());
+        assert_eq!(
+            crate::managed_install::package_root(home.path()),
+            home.path().join("packages/standalone")
+        );
+        assert_eq!(
+            (
+                old_backend.is_starting_or_running().await.unwrap(),
+                old_updater.is_starting_or_running().await.unwrap()
+            ),
+            (running, running)
+        );
+        let compatible = FakeInstallerHttp::new(InstallerResponse::Success(script.replace("else exit 2", "elif [ \"$4\" = --check-package-ownership ] || [ \"$4\" = --help ]; then exit 0; else exec sleep 30").into_bytes()));
+        let output = super::migration::run(&compatible, &legacy).await.unwrap();
+        assert_eq!(output, UpdateOutput {
+        status: UpdateStatus::Updated,
+        installed_version: Some("1.0.0".to_string()),
+        running_version: (running).then(|| "1.0.0".to_string()),
+        managed_codex_path: dedicated.join("current/bin/codex"),
+        message: "The daemon was updated and moved to its dedicated package. The legacy CLI package was left unchanged.".to_string(),
+    });
+        assert_eq!(
+            crate::managed_install::package_root(home.path()),
+            dedicated.clone()
+        );
+        assert!(!dedicated.join(".migration-current").exists());
+        assert_eq!(
+            std::fs::read(&legacy.managed_codex_bin).unwrap(),
+            legacy_bin
+        );
+        assert_eq!(
+            std::fs::read_to_string(&legacy.settings_file).unwrap(),
+            settings
+        );
+        let selected = Daemon {
+            pid_file: legacy.pid_file.with_file_name(crate::DAEMON_PID_FILE_NAME),
+            update_pid_file: legacy
+                .update_pid_file
+                .with_file_name(crate::DAEMON_UPDATE_PID_FILE_NAME),
+            managed_codex_bin: dedicated.join("current/bin/codex"),
+            ..legacy.clone()
+        };
+        let new_backend = crate::backend::pid_backend(selected.backend_paths(&daemon_settings));
+        assert_eq!(new_backend.is_starting_or_running().await.unwrap(), running);
+        assert!(!old_backend.is_starting_or_running().await.unwrap());
+        assert!(!old_updater.is_starting_or_running().await.unwrap());
+        let new_updater =
+            crate::backend::pid_update_loop_backend(selected.backend_paths(&daemon_settings));
+        assert_eq!(new_updater.is_starting_or_running().await.unwrap(), running);
+        new_updater.stop().await.unwrap();
+        new_backend.stop().await.unwrap();
+        if let Some(server) = server {
+            server.abort();
+        }
+    }
+}
+
 impl FakeInstallerHttp {
     fn new(response: InstallerResponse) -> Self {
         Self {
@@ -108,9 +237,12 @@ async fn cancelling_installer_stops_children_and_releases_fallback_lock() {
     });
     let result = tokio::time::timeout(
         Duration::from_secs(10),
-        super::run_installer_script(script.as_bytes(), "0.150.0-test", home.path(), async {
-            cancelled.await.ok()
-        }),
+        super::run_installer_script(
+            script.as_bytes(),
+            super::InstallerMode::Update("0.150.0-test"),
+            &home.path().join("packages/standalone"),
+            async { cancelled.await.ok() },
+        ),
     )
     .await
     .expect("installer cancellation timed out")
@@ -146,6 +278,8 @@ fn manual_update_daemon(home: &TempDir) -> (Daemon, String) {
         .expect("current release");
     std::fs::write(standalone.join("auto-update-version"), &release).expect("latest marker");
     let state = home.path().join("app-server-daemon");
+    std::fs::create_dir(&state).unwrap();
+    std::fs::write(state.join("app-server.stderr.log"), b"").unwrap();
     (
         Daemon {
             socket_path: home.path().join("app-server-control/server.sock"),
@@ -313,30 +447,19 @@ async fn unsupported_request_preserves_updater_schedule() {
 }
 
 #[cfg(unix)]
-#[tokio::test]
-async fn manual_update_restarts_managed_daemon_with_automatic_updates_disabled() {
+async fn test_control_server(
+    daemon: &Daemon,
+    home: &std::path::Path,
+) -> tokio::task::JoinHandle<()> {
     use futures::SinkExt;
     use futures::StreamExt;
-    use tokio::io::AsyncReadExt;
-    use tokio::io::AsyncWriteExt;
-
-    let home = TempDir::new().expect("home");
-    let (daemon, release) = manual_update_daemon(&home);
-    let daemon = std::sync::Arc::new(daemon);
-    std::fs::create_dir_all(daemon.settings_file.parent().expect("state directory"))
-        .expect("state directory");
-    std::fs::write(
-        &daemon.settings_file,
-        r#"{"updater":{"autoUpdateEnabled":false}}"#,
-    )
-    .expect("disabled updater");
     std::fs::create_dir_all(daemon.socket_path.parent().expect("socket parent"))
         .expect("socket directory");
     let mut listener = codex_uds::UnixListener::bind(&daemon.socket_path)
         .await
         .expect("control listener");
-    let codex_home = home.path().to_path_buf();
-    let server = tokio::spawn(async move {
+    let codex_home = home.to_path_buf();
+    tokio::spawn(async move {
         loop {
             let connection = listener.accept().await.expect("control connection");
             let mut websocket = tokio_tungstenite::accept_async(connection)
@@ -348,7 +471,7 @@ async fn manual_update_restarts_managed_daemon_with_automatic_updates_disabled()
                 .expect("initialize request")
                 .expect("frame");
             let version = if std::fs::read_to_string(
-                codex_home.join("packages/standalone/auto-update-version"),
+                crate::managed_install::package_root(&codex_home).join("auto-update-version"),
             )
             .expect("selected release")
             .starts_with("1.1.0")
@@ -369,7 +492,26 @@ async fn manual_update_restarts_managed_daemon_with_automatic_updates_disabled()
                 .expect("initialized notification")
                 .expect("frame");
         }
-    });
+    })
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn manual_update_restarts_managed_daemon_with_automatic_updates_disabled() {
+    use tokio::io::AsyncReadExt;
+    use tokio::io::AsyncWriteExt;
+
+    let home = TempDir::new().expect("home");
+    let (daemon, release) = manual_update_daemon(&home);
+    let daemon = std::sync::Arc::new(daemon);
+    std::fs::create_dir_all(daemon.settings_file.parent().expect("state directory"))
+        .expect("state directory");
+    std::fs::write(
+        &daemon.settings_file,
+        r#"{"updater":{"autoUpdateEnabled":false}}"#,
+    )
+    .expect("disabled updater");
+    let server = test_control_server(&daemon, home.path()).await;
     let settings = crate::settings::DaemonSettings::default();
     let backend = crate::backend::pid_backend(daemon.backend_paths(&settings));
     backend.start().await.expect("start daemon");
@@ -492,6 +634,7 @@ async fn powershell_installer_is_noninteractive_and_reports_script_failure() {
         br#"
 function Test-Installer {
     if ($env:CODEX_NON_INTERACTIVE -ne '1') { throw 'interactive installer' }
+    if ($env:CODEX_INSTALL_DAEMON_ONLY -ne '1') { throw 'wrong package destination' }
 }
 Test-Installer
 "#
@@ -500,9 +643,13 @@ Test-Installer
     let script = super::fetch_installer_script(&valid)
         .await
         .expect("fetch installer");
-    super::run_installer_script(&script, "0.150.0-x86_64-pc-windows-msvc")
-        .await
-        .expect("installer succeeds");
+    super::run_installer_script(
+        &script,
+        super::InstallerMode::Update("0.150.0-x86_64-pc-windows-msvc"),
+        std::path::Path::new("packages/app-server-daemon"),
+    )
+    .await
+    .expect("installer succeeds");
     let failing = FakeInstallerHttp::new(InstallerResponse::Success(
         b"throw 'installer failed'".to_vec(),
     ));
@@ -510,8 +657,75 @@ Test-Installer
         .await
         .expect("fetch failing installer");
     assert!(
-        super::run_installer_script(&script, "0.150.0-x86_64-pc-windows-msvc")
-            .await
-            .is_err()
+        super::run_installer_script(
+            &script,
+            super::InstallerMode::Update("0.150.0-x86_64-pc-windows-msvc"),
+            std::path::Path::new("packages/app-server-daemon")
+        )
+        .await
+        .is_err()
     );
 }
+
+#[cfg(unix)]
+#[tokio::test]
+async fn update_rejects_a_package_root_change_during_download() {
+    struct ChangingRoot<'a>(&'a std::path::Path);
+    impl InstallerHttp for ChangingRoot<'_> {
+        async fn get(&self, _url: &str) -> anyhow::Result<InstallerResponse> {
+            std::os::unix::fs::symlink(
+                self.0.join("packages/standalone"),
+                self.0.join("packages/app-server-daemon"),
+            )?;
+            Ok(InstallerResponse::Success(
+                b"# CODEX_INSTALL_IF_LATEST\nexit 99\n".to_vec(),
+            ))
+        }
+    }
+    let home = TempDir::new().unwrap();
+    let (daemon, _) = manual_update_daemon(&home);
+    let identity = executable_identity(&daemon.managed_codex_bin)
+        .await
+        .unwrap();
+    let error = manual_update_once(
+        &ChangingRoot(home.path()),
+        &daemon,
+        &identity,
+        &mut test_terminate(),
+    )
+    .await
+    .unwrap_err();
+    assert!(error.to_string().contains("package root changed"));
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn daemon_owned_updates_require_and_request_an_isolated_installer() {
+    let home = TempDir::new().unwrap();
+    let (mut daemon, _) = manual_update_daemon(&home);
+    let root = home.path().join("packages/app-server-daemon");
+    std::fs::rename(home.path().join("packages/standalone"), &root).unwrap();
+    daemon.managed_codex_bin = root.join("current/codex");
+    let identity = executable_identity(&daemon.managed_codex_bin)
+        .await
+        .unwrap();
+    let old = FakeInstallerHttp::new(InstallerResponse::Success(
+        b"# CODEX_INSTALL_IF_LATEST\nexit 0\n".to_vec(),
+    ));
+    let error = manual_update_once(&old, &daemon, &identity, &mut test_terminate())
+        .await
+        .unwrap_err();
+    assert!(
+        error
+            .to_string()
+            .contains("does not support daemon-owned packages")
+    );
+    let current = FakeInstallerHttp::new(InstallerResponse::Success(
+        b"# CODEX_INSTALL_IF_LATEST\ntest \"$CODEX_INSTALL_DAEMON_ONLY\" = 1\n".to_vec(),
+    ));
+    let output = manual_update_once(&current, &daemon, &identity, &mut test_terminate())
+        .await
+        .unwrap();
+    assert_eq!(output.status, UpdateStatus::NoUpdate);
+    assert!(!home.path().join("packages/standalone").exists());
+}
diff --git a/codex-rs/cli/src/doctor/background.rs b/codex-rs/cli/src/doctor/background.rs
index 7a4dc516c3..b6d13de058 100644
--- a/codex-rs/cli/src/doctor/background.rs
+++ b/codex-rs/cli/src/doctor/background.rs
@@ -55,6 +55,16 @@ pub(super) async fn background_server_check(config: &Config) -> DoctorCheck {
         "update-loop pid file",
         &state_dir.join(UPDATE_PID_FILE_NAME),
     );
+    push_file_detail(
+        &mut details,
+        "dedicated pid file",
+        &state_dir.join("daemon.pid"),
+    );
+    push_file_detail(
+        &mut details,
+        "dedicated update-loop pid file",
+        &state_dir.join("daemon-updater.pid"),
+    );
     push_configured_updater(&mut details, &state_dir.join(SETTINGS_FILE_NAME));
 
     let socket_path = match codex_app_server::app_server_control_socket_path(&config.codex_home) {
@@ -322,6 +332,7 @@ mod tests {
                 detail.starts_with("automatic updates:")
                     || detail.starts_with("update interval:")
                     || detail.starts_with("update-loop pid file:")
+                    || detail.starts_with("dedicated")
             })
             .map(|detail| {
                 detail
diff --git a/codex-rs/cli/src/doctor/snapshots/codex__doctor__background__tests__configured_updater.snap b/codex-rs/cli/src/doctor/snapshots/codex__doctor__background__tests__configured_updater.snap
index 63f0df4058..478f044f1e 100644
--- a/codex-rs/cli/src/doctor/snapshots/codex__doctor__background__tests__configured_updater.snap
+++ b/codex-rs/cli/src/doctor/snapshots/codex__doctor__background__tests__configured_updater.snap
@@ -1,8 +1,9 @@
 ---
 source: cli/src/doctor/background.rs
-assertion_line: 332
 expression: details
 ---
 update-loop pid file: CODEX_HOME/app-server-daemon/app-server-updater.pid (missing)
+dedicated pid file: CODEX_HOME/app-server-daemon/daemon.pid (missing)
+dedicated update-loop pid file: CODEX_HOME/app-server-daemon/daemon-updater.pid (missing)
 automatic updates: disabled (configured)
 update interval: 90 minutes (configured)
diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rs
index 9e8e014d14..68de6ec0d8 100644
--- a/codex-rs/cli/src/main.rs
+++ b/codex-rs/cli/src/main.rs
@@ -809,7 +809,11 @@ enum AppServerDaemonSubcommand {
 
     /// [internal] Run the detached pid-backed standalone updater loop.
     #[clap(hide = true)]
-    PidUpdateLoop,
+    PidUpdateLoop {
+        /// Check support for daemon-owned packages without starting the updater.
+        #[arg(long, hide = true)]
+        check_package_ownership: bool,
+    },
 }
 
 #[derive(Debug, Args)]
@@ -1392,10 +1396,6 @@ async fn cli_main(
                     AppServerDaemonSubcommand::Restart => {
                         print_app_server_daemon_output(AppServerLifecycleCommand::Restart).await?;
                     }
-                    AppServerDaemonSubcommand::Update => {
-                        let output = codex_app_server_daemon::update().await?;
-                        println!("{}", serde_json::to_string(&output)?);
-                    }
                     AppServerDaemonSubcommand::EnableRemoteControl => {
                         print_app_server_remote_control_output(AppServerRemoteControlMode::Enabled)
                             .await?;
@@ -1412,7 +1412,13 @@ async fn cli_main(
                     AppServerDaemonSubcommand::Version => {
                         print_app_server_daemon_output(AppServerLifecycleCommand::Version).await?;
                     }
-                    AppServerDaemonSubcommand::PidUpdateLoop => {
+                    AppServerDaemonSubcommand::PidUpdateLoop {
+                        check_package_ownership: true,
+                    } => return Ok(()),
+                    AppServerDaemonSubcommand::Update
+                    | AppServerDaemonSubcommand::PidUpdateLoop {
+                        check_package_ownership: false,
+                    } => {
                         let cli_overrides = root_config_overrides
                             .parse_overrides()
                             .map_err(anyhow::Error::msg)?;
@@ -1422,7 +1428,14 @@ async fn cli_main(
                             .await
                             .map_err(anyhow::Error::from);
                         let http_client_factory = updater_http_client_factory(config);
-                        codex_app_server_daemon::run_pid_update_loop(http_client_factory).await?;
+                        if matches!(daemon_cli.subcommand, AppServerDaemonSubcommand::Update) {
+                            let output =
+                                codex_app_server_daemon::update(http_client_factory).await?;
+                            println!("{}", serde_json::to_string(&output)?);
+                        } else {
+                            codex_app_server_daemon::run_pid_update_loop(http_client_factory)
+                                .await?;
+                        }
                     }
                 },
                 Some(AppServerSubcommand::Proxy(proxy_cli)) => {
@@ -2643,7 +2656,7 @@ fn app_server_subcommand_name(subcommand: Option<&AppServerSubcommand>) -> &'sta
             }
             AppServerDaemonSubcommand::Stop => "app-server daemon stop",
             AppServerDaemonSubcommand::Version => "app-server daemon version",
-            AppServerDaemonSubcommand::PidUpdateLoop => "app-server daemon pid-update-loop",
+            AppServerDaemonSubcommand::PidUpdateLoop { .. } => "app-server daemon pid-update-loop",
         },
         Some(AppServerSubcommand::Proxy(_)) => "app-server proxy",
         Some(AppServerSubcommand::GenerateTs(_)) => "app-server generate-ts",
diff --git a/codex-rs/cli/tests/app_server_daemon.rs b/codex-rs/cli/tests/app_server_daemon.rs
index 79ab3b3be7..bd90b5b59c 100644
--- a/codex-rs/cli/tests/app_server_daemon.rs
+++ b/codex-rs/cli/tests/app_server_daemon.rs
@@ -44,6 +44,10 @@ impl TestDaemon {
             PathBuf::from("releases").join(release_name),
             standalone.join("current"),
         )?;
+        // Model a daemon that was previously launched and is currently stopped.
+        let state = home.path().join("app-server-daemon");
+        std::fs::create_dir(&state)?;
+        std::fs::write(state.join("app-server.stderr.log"), b"")?;
         Ok(Self {
             home,
             codex,
@@ -118,6 +122,29 @@ fn wait_for_exit(pid: u32) -> Result<()> {
     }
 }
 
+#[test]
+fn package_ownership_check_does_not_start_an_updater() -> Result<()> {
+    let daemon = TestDaemon::new()?;
+    let output = daemon
+        .command()
+        .args([
+            "app-server",
+            "daemon",
+            "pid-update-loop",
+            "--check-package-ownership",
+        ])
+        .output()?;
+    ensure!(
+        output.status.success(),
+        "ownership check failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let state = daemon.home.path().join("app-server-daemon");
+    assert!(!state.join("app-server-updater.pid").exists());
+    assert!(!state.join("daemon-updater.pid").exists());
+    Ok(())
+}
+
 #[test]
 fn managed_starts_ensure_one_updater_and_recover_a_missing_one() -> Result<()> {
     let daemon = TestDaemon::new()?;
@@ -139,6 +166,22 @@ fn managed_starts_ensure_one_updater_and_recover_a_missing_one() -> Result<()> {
     assert_eq!(daemon.lifecycle("restart")?["status"], "restarted");
     assert_ne!(daemon.pid("app-server.pid")?, backend_pid);
     assert_eq!(daemon.pid("app-server-updater.pid")?, replacement_pid);
+    daemon.lifecycle("stop")?;
+    assert!(
+        !daemon
+            .home
+            .path()
+            .join("app-server-daemon/app-server.pid")
+            .exists()
+    );
+    assert_eq!(daemon.lifecycle("start")?["status"], "started");
+    assert!(
+        !daemon
+            .home
+            .path()
+            .join("packages/app-server-daemon")
+            .exists()
+    );
     Ok(())
 }
 
diff --git a/scripts/install/install.ps1 b/scripts/install/install.ps1
index 229663b166..535bcc31f5 100644
--- a/scripts/install/install.ps1
+++ b/scripts/install/install.ps1
@@ -903,9 +903,15 @@ $codexHome = if ([string]::IsNullOrWhiteSpace($env:CODEX_HOME)) {
 } else {
     $env:CODEX_HOME
 }
-$standaloneRoot = Join-Path $codexHome "packages\standalone"
+$daemonOnly = $env:CODEX_INSTALL_DAEMON_ONLY -eq "1"
+$standaloneRoot = Join-Path $codexHome $(if ($daemonOnly) { "packages\app-server-daemon" } else { "packages\standalone" })
 $releasesDir = Join-Path $standaloneRoot "releases"
 $currentDir = Join-Path $standaloneRoot "current"
+$deferSelection = $env:CODEX_INSTALL_DEFER_SELECTION -eq "1"
+if ($deferSelection) {
+    if (-not $daemonOnly) { throw "Deferred selection requires a daemon-only installation." }
+    $currentDir = Join-Path $standaloneRoot ".migration-current"
+}
 $autoUpdateVersion = Join-Path $standaloneRoot "auto-update-version"
 $lockPath = Join-Path $standaloneRoot "install.lock"
 
@@ -933,7 +939,7 @@ if (-not [string]::IsNullOrWhiteSpace($currentVersion) -and $currentVersion -ne
 Write-Step "Detected platform: $platformLabel"
 Write-Step "Resolved version: $resolvedVersion"
 
-$conflictingInstall = Get-ConflictingInstall -VisibleBinDir $visibleBinDir
+$conflictingInstall = if ($daemonOnly) { $null } else { Get-ConflictingInstall -VisibleBinDir $visibleBinDir }
 $oldStandaloneBackup = $null
 
 $checksumAsset = "codex-package_SHA256SUMS"
@@ -949,6 +955,7 @@ $guardRejected = $false
 try {
     Invoke-WithInstallLock -LockPath $lockPath -Script {
         $updaterRecord = Join-Path $codexHome "app-server-daemon\app-server-updater.pid"
+        if ($daemonOnly) { $updaterRecord = Join-Path $codexHome "app-server-daemon\daemon-updater.pid" }
         $oldUpdaterParent = $false
         if ($Release -eq "latest" -and $env:CODEX_INSTALL_IF_LATEST -ne "1" -and (Test-Path -LiteralPath $updaterRecord)) {
             $updaterPid = $null
@@ -997,6 +1004,7 @@ try {
 
         if (-not (Test-ReleaseIsComplete -ReleaseDir $releaseDir -ExpectedVersion $resolvedVersion -ExpectedTarget $target -Layout $installLayout)) {
             if (Test-Path -LiteralPath $releaseDir) {
+                if ($daemonOnly) { throw "Refusing to overwrite existing daemon release $releaseDir." }
                 Write-WarningStep "Found incomplete existing release at $releaseDir. Reinstalling."
             }
 
@@ -1058,6 +1066,9 @@ try {
         }
 
         New-Item -ItemType Directory -Force -Path $standaloneRoot | Out-Null
+        if ($deferSelection -and (Get-Item -LiteralPath (Join-Path $standaloneRoot "current") -Force -ErrorAction SilentlyContinue)) {
+            throw "A dedicated daemon is already selected; retry the update."
+        }
         Ensure-Junction -LinkPath $currentDir -TargetPath $releaseDir -InstallerOwnedTargetPrefix $releasesDir
         if ($Release -eq "latest") {
             $tempMarker = "$autoUpdateVersion.tmp.$PID"
@@ -1069,6 +1080,7 @@ try {
             }
         }
 
+        if ($daemonOnly) { return }
         $visibleParent = Split-Path -Parent $visibleBinDir
         $currentBinDir = if ($installLayout -eq "Package") {
             Join-Path $currentDir "bin"
@@ -1096,7 +1108,7 @@ try {
 } finally {
     Remove-Item -Recurse -Force $tempDir -ErrorAction SilentlyContinue
 }
-if ($guardRejected) { return }
+if ($guardRejected -or $daemonOnly) { return }
 
 Maybe-HandleConflictingInstall -Conflict $conflictingInstall
 
diff --git a/scripts/install/install.sh b/scripts/install/install.sh
index 4a2b4ece49..f230ac0586 100755
--- a/scripts/install/install.sh
+++ b/scripts/install/install.sh
@@ -4,6 +4,7 @@ set -eu
 
 RELEASE="${CODEX_RELEASE:-latest}"
 NON_INTERACTIVE="${CODEX_NON_INTERACTIVE:-false}"
+DAEMON_ONLY="${CODEX_INSTALL_DAEMON_ONLY:-0}"
 DEFAULT_PREFER_RELEASES_OPENAI_COM="true"
 PREFER_RELEASES_OPENAI_COM="${CODEX_INSTALLER_USE_RELEASES_OPENAI_COM:-$DEFAULT_PREFER_RELEASES_OPENAI_COM}"
 RELEASES_BASE_URL="https://releases.openai.com/codex"
@@ -17,8 +18,18 @@ BIN_PATH="$BIN_DIR/codex"
 CODE_MODE_HOST_BIN_PATH="$BIN_DIR/codex-code-mode-host"
 CODEX_HOME_DIR="${CODEX_HOME:-$HOME/.codex}"
 STANDALONE_ROOT="$CODEX_HOME_DIR/packages/standalone"
+if [ "$DAEMON_ONLY" = "1" ]; then
+  STANDALONE_ROOT="$CODEX_HOME_DIR/packages/app-server-daemon"
+fi
 RELEASES_DIR="$STANDALONE_ROOT/releases"
 CURRENT_LINK="$STANDALONE_ROOT/current"
+if [ "${CODEX_INSTALL_DEFER_SELECTION:-0}" = "1" ]; then
+  if [ "$DAEMON_ONLY" != "1" ]; then
+    echo "Deferred selection requires a daemon-only installation." >&2
+    exit 1
+  fi
+  CURRENT_LINK="$STANDALONE_ROOT/.migration-current"
+fi
 AUTO_UPDATE_VERSION="$STANDALONE_ROOT/auto-update-version"
 LOCK_FILE="$STANDALONE_ROOT/install.lock"
 LOCK_DIR="$STANDALONE_ROOT/install.lock.d"
@@ -742,7 +753,7 @@ cleanup_stale_install_artifacts() {
   find "$RELEASES_DIR" -mindepth 1 -maxdepth 1 -name '.staging.*' -exec rm -rf {} +
   find "$STANDALONE_ROOT" -mindepth 1 -maxdepth 1 -name '.current.*' -exec rm -f {} +
 
-  if [ -d "$BIN_DIR" ]; then
+  if [ "$DAEMON_ONLY" != "1" ] && [ -d "$BIN_DIR" ]; then
     find "$BIN_DIR" -mindepth 1 -maxdepth 1 -name '.codex.*' -exec rm -f {} +
   fi
 }
@@ -1140,7 +1151,9 @@ fi
 step "Detected platform: $platform_label"
 step "Resolved version: $resolved_version"
 
-detect_conflicting_install
+if [ "$DAEMON_ONLY" != "1" ]; then
+  detect_conflicting_install
+fi
 
 tmp_dir="$(mktemp -d)"
 cleanup() {
@@ -1154,7 +1167,15 @@ trap 'exit 130' INT
 trap 'exit 143' TERM
 
 acquire_install_lock
+if [ "${CODEX_INSTALL_DEFER_SELECTION:-0}" = "1" ] &&
+  { [ -e "$STANDALONE_ROOT/current" ] || [ -L "$STANDALONE_ROOT/current" ]; }; then
+  echo "A dedicated daemon is already selected; retry the update." >&2
+  exit 1
+fi
 updater_record="$CODEX_HOME_DIR/app-server-daemon/app-server-updater.pid"
+if [ "$DAEMON_ONLY" = "1" ]; then
+  updater_record="$CODEX_HOME_DIR/app-server-daemon/daemon-updater.pid"
+fi
 old_updater_parent="false"
 if [ "${CODEX_INSTALL_IF_LATEST:-}" != "1" ] && [ -f "$updater_record" ]; then
   updater_pid="$(sed -n 's/.*"pid"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$updater_record" | head -n 1)"
@@ -1197,6 +1218,10 @@ cleanup_stale_install_artifacts
 
 if ! release_dir_is_complete "$release_dir" "$resolved_version" "$vendor_target" "$install_layout"; then
   if [ -e "$release_dir" ] || [ -L "$release_dir" ]; then
+    if [ "$DAEMON_ONLY" = "1" ]; then
+      echo "Refusing to overwrite existing daemon release $release_dir." >&2
+      exit 1
+    fi
     warn "Found incomplete existing release at $release_dir; reinstalling."
   fi
 
@@ -1231,6 +1256,10 @@ if [ "$RELEASE" = "latest" ]; then
 else
   rm -f "$AUTO_UPDATE_VERSION"
 fi
+if [ "$DAEMON_ONLY" = "1" ]; then
+  release_install_lock
+  exit 0
+fi
 update_visible_command "$release_dir"
 add_to_path
 verify_visible_command
diff --git a/scripts/install/test_install_sh.py b/scripts/install/test_install_sh.py
index a754ab21cf..5ac63ce4fa 100644
--- a/scripts/install/test_install_sh.py
+++ b/scripts/install/test_install_sh.py
@@ -156,6 +156,40 @@ class InstallShTest(unittest.TestCase):
                 ],
             )
 
+    def test_daemon_install_preserves_visible_cli_and_profile(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir).resolve()
+            archive, checksum, metadata = create_package_release(root)
+            options = dict(
+                metadata_json=metadata,
+                archive_path=archive,
+                checksum_path=checksum,
+                force_macos=True,
+            )
+            pinned, _ = run_installer_in(root, VERSION, **options)
+            self.assertEqual(pinned.returncode, 0, pinned.stderr)
+            visible = root / "install-bin/codex"
+            original = visible.resolve()
+            pending = visible.with_name(".codex.12345")
+            pending.symlink_to(original)
+            profile = root / "home/.profile"
+            profile.write_text("unchanged profile\n")
+
+            installed, _ = run_installer_in(root, "latest", daemon_only=True, **options)
+            self.assertEqual(installed.returncode, 0, installed.stderr)
+            daemon = root / "codex-home/packages/app-server-daemon"
+            release_name = f"{VERSION}-aarch64-apple-darwin"
+            self.assertEqual(
+                (daemon / "current").resolve(), daemon / "releases" / release_name
+            )
+            self.assertEqual((daemon / "auto-update-version").read_text(), release_name)
+            self.assertEqual(visible.resolve(), original)
+            self.assertTrue(pending.is_symlink())
+            self.assertEqual(profile.read_text(), "unchanged profile\n")
+            self.assertFalse(
+                (root / "codex-home/packages/standalone/auto-update-version").exists()
+            )
+
     def test_explicit_release_pins_even_the_current_latest_version(self) -> None:
         with tempfile.TemporaryDirectory() as temp_dir:
             root = Path(temp_dir)
@@ -637,6 +671,7 @@ def run_installer_in(
     update_guard_from_release: str | None = None,
     old_updater_parent_pid: int | None = None,
     fail_ps: bool = False,
+    daemon_only: bool = False,
 ) -> tuple[subprocess.CompletedProcess[str], list[str]]:
     bin_dir = root / "bin"
     bin_dir.mkdir(exist_ok=True)
@@ -771,6 +806,7 @@ def run_installer_in(
             "CODEX_INSTALL_DIR": str(root / "install-bin"),
             "CODEX_NON_INTERACTIVE": "1",
             "CODEX_RELEASE": release,
+            "CODEX_INSTALL_DAEMON_ONLY": "1" if daemon_only else "0",
             "CODEX_TEST_ARCHIVE_PATH": str(archive_path or ""),
             "CODEX_TEST_CHECKSUM_PATH": str(checksum_path or ""),
             "CODEX_TEST_RELEASES_CHECKSUM_PATH": str(