diff --git a/apps/codex-plus-manager/src-tauri/src/commands.rs b/apps/codex-plus-manager/src-tauri/src/commands.rs
index 7de91430e..e0a8b3b69 100644
--- a/apps/codex-plus-manager/src-tauri/src/commands.rs
+++ b/apps/codex-plus-manager/src-tauri/src/commands.rs
@@ -1364,6 +1364,22 @@ fn launch_codex_multi_instance_blocking(request: CodexMultiLaunchRequest) -> Com
         );
     }
     let worker_options_path = root.join("worker-options.json");
+    let _lifecycle = match codex_plus_core::multi_worker::lock_instance_lifecycle(&root) {
+        Ok(lock) => lock,
+        Err(error) => return failed(&format!("锁定实例生命周期失败：{error}"), json!({})),
+    };
+    let current: Option<CodexMultiInstance> = std::fs::read(multi_instance_manifest_path(&root))
+        .ok()
+        .and_then(|bytes| serde_json::from_slice(&bytes).ok());
+    if current
+        .as_ref()
+        .map(|instance| (&instance.instance_id, instance.generation))
+        != previous
+            .as_ref()
+            .map(|instance| (&instance.instance_id, instance.generation))
+    {
+        return failed("实例已换代，请刷新后重试。", json!({}));
+    }
     let worker_options = CodexMultiWorkerOptions {
         instance_id: instance_id.clone(),
         generation,
@@ -1572,8 +1588,7 @@ fn list_codex_multi_instances_blocking() -> CommandResult<CodexMultiInstancesPay
             let running = multi_instance_is_running(&instance);
             let mut current = instance;
             current.running = running;
-            current.status =
-                multi_instance_status(running, current.launch_result.as_ref()).to_string();
+            current.status = multi_instance_snapshot_status(&current, running).to_string();
             if !running {
                 current.pid = None;
             }
@@ -1642,71 +1657,14 @@ fn stop_codex_multi_instance_blocking(
             },
         );
     }
-    let Some(identity) = instance
-        .identity
-        .as_ref()
-        .filter(|identity| multi_manifest_identity_matches(&instance, identity))
-    else {
+    if let Err(error) = stop_multi_instance_lifecycle(&path, &instance) {
         return failed(
-            "该清单缺少可验证的实例身份，已拒绝结束进程；请手动关闭旧实例后重新启动。",
-            CodexMultiInstancesPayload {
-                instances: Vec::new(),
-            },
-        );
-    };
-    if !multi_instance_is_running(&instance)
-        && !matches!(
-            codex_plus_core::watcher::inspect_process_instance(identity.process_id),
-            codex_plus_core::watcher::ProcessInstanceState::NotRunning
-        )
-    {
-        return failed(
-            "无法重新确认该实例的完整身份，已拒绝结束进程。",
+            &format!("安全停止实例未完成：{error:#}；旧实例可手动关闭后再次点击结束以核验清理。"),
             CodexMultiInstancesPayload {
                 instances: Vec::new(),
             },
         );
     }
-    if multi_instance_is_running(&instance) {
-        match tauri::async_runtime::block_on(
-            codex_plus_core::multi_worker::terminate_verified_codex_instance(identity),
-        ) {
-            Ok(true) => {}
-            Ok(false) => {
-                return failed(
-                    "实例身份在停止前已改变，未结束任何进程。",
-                    CodexMultiInstancesPayload {
-                        instances: Vec::new(),
-                    },
-                );
-            }
-            Err(error) => {
-                return failed(
-                    &format!("安全停止实例失败：{error}"),
-                    CodexMultiInstancesPayload {
-                        instances: Vec::new(),
-                    },
-                );
-            }
-        }
-        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
-        while multi_instance_is_running(&instance) && std::time::Instant::now() < deadline {
-            std::thread::sleep(std::time::Duration::from_millis(100));
-        }
-        if multi_instance_is_running(&instance) {
-            return failed(
-                "实例仍未退出，请稍后重试。",
-                CodexMultiInstancesPayload {
-                    instances: Vec::new(),
-                },
-            );
-        }
-    }
-    // 保留该代结果作为身份记录，下次启动用新 generation 排除旧结果。
-    if let Some(pid) = instance.pid {
-        let options_path = path.join("worker-options.json");
-        let _ = terminate_multi_worker(pid, &options_path, instance.worker_birth_id);
-    }
     let _ = codex_plus_core::diagnostic_log::append_diagnostic_log(
         "manager.multi_instance_stopped",
         json!({ "instance_id": instance.instance_id, "debug_port": instance.debug_port }),
@@ -1715,6 +1673,57 @@ fn stop_codex_multi_instance_blocking(
     list_codex_multi_instances_blocking()
 }
 
+fn stop_multi_instance_lifecycle(root: &Path, instance: &CodexMultiInstance) -> anyhow::Result<()> {
+    anyhow::ensure!(
+        !multi_instance_is_starting(instance),
+        "实例正在启动，请等待启动结果后再结束或重启"
+    );
+    let cleanup = (|| {
+        if let Some(identity) = instance.identity.as_ref() {
+            anyhow::ensure!(
+                multi_manifest_identity_matches(instance, identity),
+                "实例身份不一致"
+            );
+            #[cfg(any(windows, target_os = "macos"))]
+            let exited = codex_plus_core::multi_worker::codex_process_generation_exited(
+                identity.process_id,
+                Some(identity.process_birth_id),
+            )?;
+            #[cfg(not(any(windows, target_os = "macos")))]
+            let exited = false;
+            if !exited {
+                anyhow::ensure!(
+                    tauri::async_runtime::block_on(
+                        codex_plus_core::multi_worker::terminate_verified_codex_instance(identity),
+                    )?,
+                    "实例身份改变，未结束任何进程"
+                );
+            }
+            wait_for_multi_instance_absence(instance, multi_instance_resources_are_absent)?;
+        } else {
+            anyhow::ensure!(
+                stale_multi_instance_is_absent(instance)?
+                    && stale_multi_instance_is_absent(instance)?,
+                "清单缺少可验证身份，仍有进程或端口占用，不能安全结束"
+            );
+        }
+        if let Some(pid) = instance.pid
+            && wait_for_multi_instance_absence(instance, stale_multi_instance_is_absent).is_err()
+        {
+            terminate_multi_worker(
+                pid,
+                &root.join("worker-options.json"),
+                instance.worker_birth_id,
+            )?;
+            anyhow::bail!("worker 未正常结束，已执行安全清理；请再次结束以核验最终状态");
+        }
+        wait_for_multi_instance_absence(instance, stale_multi_instance_is_absent)
+    })();
+    finish_multi_instance_cleanup(root, instance, cleanup, stale_multi_instance_is_absent)?;
+    load_multi_instance_manifest(root)?;
+    Ok(())
+}
+
 #[tauri::command]
 pub async fn restart_codex_multi_instance(
     request: CodexMultiInstanceRequest,
@@ -1801,18 +1810,49 @@ fn multi_manifest_identity_matches(
 }
 
 fn load_multi_instance_manifest(root: &Path) -> anyhow::Result<CodexMultiInstance> {
-    let mut instance: CodexMultiInstance =
-        serde_json::from_slice(&std::fs::read(multi_instance_manifest_path(root))?)?;
-    if let Some(result) = load_multi_launch_result(root).filter(|result| {
-        result.generation != 0
-            && result.generation == instance.generation
-            && result.instance_id == instance.instance_id
-    }) {
+    load_multi_instance_manifest_with_absence(root, stale_multi_instance_is_absent)
+}
+
+fn load_multi_instance_manifest_with_absence(
+    root: &Path,
+    absent: impl Fn(&CodexMultiInstance) -> anyhow::Result<bool>,
+) -> anyhow::Result<CodexMultiInstance> {
+    let _lifecycle = codex_plus_core::multi_worker::lock_instance_lifecycle(root)?;
+    let manifest_bytes = std::fs::read(multi_instance_manifest_path(root))?;
+    let mut instance: CodexMultiInstance = serde_json::from_slice(&manifest_bytes)?;
+    let result_bytes = match read_multi_launch_result_bytes(root) {
+        Ok(bytes) => bytes,
+        Err(_) => {
+            instance.status = "unknown".into();
+            instance.launch_result = None;
+            return Ok(instance);
+        }
+    };
+    let mut manifest_changed = false;
+    let mut stopped_receipt_confirmed = false;
+    let mut can_reconcile = result_bytes.is_none();
+    let mut receipt_changed = false;
+    if let Some(result) = result_bytes
+        .as_deref()
+        .and_then(|bytes| serde_json::from_slice::<CodexMultiLaunchResult>(bytes).ok())
+        .filter(|result| {
+            (result.generation != 0
+                || matches!(result.status.as_str(), "stopped" | "cleanup_failed")
+                    && result.identity.is_none())
+                && result.generation == instance.generation
+                && result.instance_id == instance.instance_id
+        })
+    {
         if let Some(identity) = &result.identity {
             let mut updated = instance.clone();
             updated.debug_port = result.debug_port.unwrap_or(0);
             updated.helper_port = result.helper_port.unwrap_or(0);
-            if multi_manifest_identity_matches(&updated, identity) {
+            if multi_manifest_identity_matches(&updated, identity)
+                && instance
+                    .identity
+                    .as_ref()
+                    .is_none_or(|saved| saved == identity)
+            {
                 updated.identity = Some(identity.clone());
                 updated.launch_result = Some(result.clone());
                 // 同一代启动回执才可更新清单；读列表不会把旧结果提升为新实例。
@@ -1820,16 +1860,156 @@ fn load_multi_instance_manifest(root: &Path) -> anyhow::Result<CodexMultiInstanc
                     || instance.debug_port != updated.debug_port
                     || instance.helper_port != updated.helper_port
                 {
-                    save_multi_instance_manifest(root, &updated)?;
+                    manifest_changed = true;
                 }
                 instance = updated;
             }
         }
+        stopped_receipt_confirmed = multi_instance_stopped_receipt_matches(&instance, &result);
+        let mut stopped = result.clone();
+        stopped.status = "stopped".into();
+        can_reconcile = matches!(
+            result.status.as_str(),
+            "ready" | "ready_degraded" | "failed" | "cleanup_failed" | "stopped"
+        ) && multi_instance_stopped_receipt_matches(&instance, &stopped);
         instance.launch_result = Some(result);
     }
+    if instance.status != "stopped"
+        && !instance.is_main
+        && instance.instance_id != "main"
+        && !instance.instance_id.is_empty()
+        && can_reconcile
+        && absent(&instance).unwrap_or(false)
+        && absent(&instance).unwrap_or(false)
+    {
+        if !stopped_receipt_confirmed {
+            instance.launch_result = Some(multi_instance_cleanup_result(&instance, &Ok(())));
+            receipt_changed = true;
+        }
+        instance.status = "stopped".into();
+        instance.running = false;
+        instance.pid = None;
+        instance.worker_birth_id = None;
+        manifest_changed = true;
+    }
+    if manifest_changed {
+        anyhow::ensure!(
+            std::fs::read(multi_instance_manifest_path(root))? == manifest_bytes,
+            "实例清单在状态核验期间改变，未覆盖记录"
+        );
+        anyhow::ensure!(
+            read_multi_launch_result_bytes(root)? == result_bytes,
+            "实例回执在状态核验期间改变，未覆盖记录"
+        );
+        if receipt_changed {
+            write_multi_launch_result(
+                &root.join(MULTI_LAUNCH_RESULT_FILE),
+                instance.launch_result.as_ref().unwrap(),
+            )?;
+        }
+        save_multi_instance_manifest(root, &instance)?;
+    }
     Ok(instance)
 }
 
+fn read_multi_launch_result_bytes(root: &Path) -> std::io::Result<Option<Vec<u8>>> {
+    match std::fs::read(root.join(MULTI_LAUNCH_RESULT_FILE)) {
+        Ok(bytes) => Ok(Some(bytes)),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(error) => Err(error),
+    }
+}
+
+fn multi_instance_stopped_receipt_matches(
+    instance: &CodexMultiInstance,
+    result: &CodexMultiLaunchResult,
+) -> bool {
+    (instance.generation != 0 || instance.identity.is_none())
+        && !instance.is_main
+        && instance.instance_id != "main"
+        && result.instance_id == instance.instance_id
+        && result.generation == instance.generation
+        && result.status == "stopped"
+        && result.debug_port == Some(instance.debug_port)
+        && result.helper_port == Some(instance.helper_port)
+        && match instance.identity.as_ref() {
+            Some(identity) => {
+                identity.process_id != 0
+                    && identity.process_birth_id != 0
+                    && !identity.browser_id.is_empty()
+                    && multi_manifest_identity_matches(instance, identity)
+                    && result.identity.as_ref() == Some(identity)
+                    && result.pid == Some(identity.process_id)
+            }
+            None => result.identity.is_none() && result.pid.is_none(),
+        }
+}
+
+fn stale_multi_instance_is_absent(instance: &CodexMultiInstance) -> anyhow::Result<bool> {
+    #[cfg(any(windows, target_os = "macos"))]
+    {
+        if let Some(pid) = instance.pid
+            && !codex_plus_core::multi_worker::codex_process_generation_exited(
+                pid,
+                instance.worker_birth_id,
+            )?
+        {
+            return Ok(false);
+        }
+        multi_instance_resources_are_absent(instance)
+    }
+    #[cfg(not(any(windows, target_os = "macos")))]
+    {
+        let _ = instance;
+        Ok(false)
+    }
+}
+
+fn multi_instance_resources_are_absent(instance: &CodexMultiInstance) -> anyhow::Result<bool> {
+    #[cfg(any(windows, target_os = "macos"))]
+    {
+        use codex_plus_core::multi_worker::{
+            codex_process_generation_exited, codex_user_data_is_absent,
+        };
+        anyhow::ensure!(
+            !instance.is_main && instance.instance_id != "main" && !instance.instance_id.is_empty(),
+            "多开身份无效"
+        );
+        if let Some(identity) = instance.identity.as_ref() {
+            anyhow::ensure!(
+                multi_manifest_identity_matches(instance, identity),
+                "多开清单身份不一致"
+            );
+            if !codex_process_generation_exited(
+                identity.process_id,
+                Some(identity.process_birth_id),
+            )? {
+                return Ok(false);
+            }
+        }
+        let app = instance
+            .app_path
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("多开清单缺少程序路径"))?;
+        let executable = codex_plus_core::app_paths::build_codex_executable(Path::new(app));
+        let user_data = instance
+            .user_data_dir
+            .as_deref()
+            .ok_or_else(|| anyhow::anyhow!("多开清单缺少数据目录"))?;
+        codex_user_data_is_absent(
+            &executable,
+            Path::new(user_data),
+            instance.debug_port,
+            instance.helper_port,
+        )
+    }
+    #[cfg(not(any(windows, target_os = "macos")))]
+    {
+        let _ = instance;
+        Ok(false)
+    }
+}
+
 fn multi_instance_is_running(instance: &CodexMultiInstance) -> bool {
     let Some(identity) = instance
         .identity
@@ -1844,6 +2024,82 @@ fn multi_instance_is_running(instance: &CodexMultiInstance) -> bool {
     .unwrap_or(false)
 }
 
+fn multi_instance_is_starting(instance: &CodexMultiInstance) -> bool {
+    if instance.is_main
+        || instance.generation == 0
+        || instance.status == "stopped"
+        || instance.identity.is_some()
+        || instance.launch_result.is_some()
+        || instance.worker_birth_id.is_none_or(|birth| birth == 0)
+    {
+        return false;
+    }
+    #[cfg(any(windows, target_os = "macos"))]
+    if let Some(pid) = instance.pid {
+        return matches!(
+            codex_plus_core::multi_worker::codex_process_generation_exited(
+                pid,
+                instance.worker_birth_id,
+            ),
+            Ok(false)
+        );
+    }
+    false
+}
+
+fn multi_instance_snapshot_status(instance: &CodexMultiInstance, running: bool) -> &'static str {
+    if running {
+        return multi_instance_status(true, instance.launch_result.as_ref());
+    }
+    if multi_instance_is_starting(instance) {
+        return "starting";
+    }
+    if instance
+        .launch_result
+        .as_ref()
+        .is_some_and(|result| result.status == "cleanup_failed")
+    {
+        return "unknown";
+    }
+    if instance.status != "stopped"
+        && instance
+            .launch_result
+            .as_ref()
+            .is_some_and(|result| result.status == "stopped")
+    {
+        return "unknown";
+    }
+    if let Some(identity) = instance.identity.as_ref() {
+        if !multi_manifest_identity_matches(instance, identity)
+            || !instance
+                .launch_result
+                .as_ref()
+                .is_some_and(|result| multi_instance_stopped_receipt_matches(instance, result))
+        {
+            return "unknown";
+        }
+        #[cfg(any(windows, target_os = "macos"))]
+        if !codex_plus_core::multi_worker::codex_process_generation_exited(
+            identity.process_id,
+            Some(identity.process_birth_id),
+        )
+        .unwrap_or(false)
+        {
+            return "unknown";
+        }
+    }
+    if instance.identity.is_none()
+        && instance.status != "stopped"
+        && !instance
+            .launch_result
+            .as_ref()
+            .is_some_and(|result| result.status == "failed")
+    {
+        return "unknown";
+    }
+    multi_instance_status(false, instance.launch_result.as_ref())
+}
+
 /// 列表里显示的状态：能跑就是运行中；跑不起来且 worker 明确报了失败才是失败，
 /// 否则只是没在运行（例如用户自己关掉了窗口）。
 fn multi_instance_status(running: bool, result: Option<&CodexMultiLaunchResult>) -> &'static str {
@@ -1934,10 +2190,23 @@ pub fn run_codex_multi_worker(options_path: &Path) -> anyhow::Result<()> {
         .filter(|port| *port != 0)
         .unwrap_or(options.helper_port);
 
-    let result_path = options_path
+    let root = options_path
         .parent()
-        .map(|root| root.join(MULTI_LAUNCH_RESULT_FILE))
-        .unwrap_or_else(|| PathBuf::from(MULTI_LAUNCH_RESULT_FILE));
+        .ok_or_else(|| anyhow::anyhow!("worker 缺少实例目录"))?;
+    let mut instance: CodexMultiInstance = {
+        let _lifecycle = codex_plus_core::multi_worker::lock_instance_lifecycle(root)?;
+        serde_json::from_slice(&std::fs::read(multi_instance_manifest_path(root))?)?
+    };
+    anyhow::ensure!(
+        instance.instance_id == options.instance_id
+            && instance.generation == options.generation
+            && instance.generation != 0
+            && instance.debug_port == options.debug_port
+            && instance.helper_port == effective_helper_port
+            && instance.user_data_dir.as_deref() == Some(options.user_data_dir.as_str())
+            && instance.app_path.as_deref() == Some(options.app_path.as_str()),
+        "worker 参数与实例清单不一致"
+    );
     // 状态文件也显式指向实例目录：`StatusStore::default()` 会解析主实例路径，
     // worker 只应写自己那份 latest-status.json。
     let instance_status_store = StatusStore::new(instance_state_dir.join("latest-status.json"));
@@ -1955,8 +2224,9 @@ pub fn run_codex_multi_worker(options_path: &Path) -> anyhow::Result<()> {
     let receipt = match codex_plus_launcher::start_with_receipt(launch_options) {
         Ok(receipt) => receipt,
         Err(error) => {
-            let _ = write_multi_launch_result(
-                &result_path,
+            let written = write_multi_instance_result(
+                root,
+                &instance,
                 &CodexMultiLaunchResult {
                     instance_id: options.instance_id.clone(),
                     generation: options.generation,
@@ -1969,7 +2239,18 @@ pub fn run_codex_multi_worker(options_path: &Path) -> anyhow::Result<()> {
                     pid: None,
                 },
             );
-            return Ok(());
+            let cleanup = codex_plus_launcher::shutdown().and_then(|()| {
+                wait_for_multi_instance_absence(&instance, multi_instance_resources_are_absent)
+            });
+            if cleanup.is_err() {
+                finish_multi_instance_cleanup(
+                    root,
+                    &instance,
+                    cleanup,
+                    multi_instance_resources_are_absent,
+                )?;
+            }
+            return written;
         }
     };
     let endpoint_ready =
@@ -1998,8 +2279,10 @@ pub fn run_codex_multi_worker(options_path: &Path) -> anyhow::Result<()> {
         message.push_str(&format!(" 实例身份验证失败：{error:#}"));
     }
     let identity = captured.ok();
-    let _ = write_multi_launch_result(
-        &result_path,
+    instance.identity = identity.clone();
+    let written = write_multi_instance_result(
+        root,
+        &instance,
         &CodexMultiLaunchResult {
             instance_id: options.instance_id.clone(),
             generation: options.generation,
@@ -2019,18 +2302,30 @@ pub fn run_codex_multi_worker(options_path: &Path) -> anyhow::Result<()> {
             pid: identity.as_ref().map(|identity| identity.process_id),
         },
     );
-    let Some(identity) = identity else {
-        let _ = codex_plus_launcher::shutdown();
-        return Ok(());
-    };
-    while tauri::async_runtime::block_on(
-        codex_plus_core::multi_worker::codex_instance_identity_matches(&identity),
-    )
-    .unwrap_or(false)
-    {
-        std::thread::sleep(std::time::Duration::from_secs(1));
+    let was_ready = identity.is_some();
+    if written.is_ok() {
+        if let Some(identity) = identity {
+            while tauri::async_runtime::block_on(
+                codex_plus_core::multi_worker::codex_instance_identity_matches(&identity),
+            )
+            .unwrap_or(false)
+            {
+                std::thread::sleep(std::time::Duration::from_secs(1));
+            }
+        }
+    }
+    let cleanup = codex_plus_launcher::shutdown().and_then(|()| {
+        wait_for_multi_instance_absence(&instance, multi_instance_resources_are_absent)
+    });
+    if was_ready || cleanup.is_err() {
+        finish_multi_instance_cleanup(
+            root,
+            &instance,
+            cleanup,
+            multi_instance_resources_are_absent,
+        )?;
     }
-    codex_plus_launcher::shutdown()
+    written
 }
 
 /// 多开实例启动结果文件名（与 `worker-options.json` 同目录）。
@@ -2082,6 +2377,159 @@ fn write_multi_launch_result(path: &Path, result: &CodexMultiLaunchResult) -> an
     codex_plus_core::settings::atomic_write(path, &bytes)
 }
 
+fn write_multi_instance_result(
+    root: &Path,
+    expected: &CodexMultiInstance,
+    result: &CodexMultiLaunchResult,
+) -> anyhow::Result<()> {
+    let _lifecycle = codex_plus_core::multi_worker::lock_instance_lifecycle(root)?;
+    let current: CodexMultiInstance =
+        serde_json::from_slice(&std::fs::read(multi_instance_manifest_path(root))?)?;
+    anyhow::ensure!(
+        !current.is_main
+            && current.instance_id != "main"
+            && (current.generation != 0
+                || matches!(result.status.as_str(), "stopped" | "cleanup_failed")
+                    && result.identity.is_none())
+            && current.instance_id == expected.instance_id
+            && current.generation == expected.generation
+            && current.debug_port == expected.debug_port
+            && current.helper_port == expected.helper_port
+            && current.user_data_dir == expected.user_data_dir
+            && current.app_path == expected.app_path
+            && current.instance_id == result.instance_id
+            && current.generation == result.generation
+            && result.debug_port == Some(current.debug_port)
+            && result.helper_port == Some(current.helper_port),
+        "实例已换代或路径、端口改变，未覆盖回执"
+    );
+    anyhow::ensure!(
+        expected
+            .identity
+            .as_ref()
+            .is_none_or(|identity| result.identity.as_ref() == Some(identity))
+            && current
+                .identity
+                .as_ref()
+                .is_none_or(|identity| result.identity.as_ref() == Some(identity))
+            && result.identity.as_ref().is_none_or(|identity| {
+                multi_manifest_identity_matches(&current, identity)
+                    && result.pid == Some(identity.process_id)
+            })
+            && (result.identity.is_some() || result.pid.is_none()),
+        "实例身份改变，未覆盖回执"
+    );
+    if let Some(saved) = load_multi_launch_result(root).filter(|saved| {
+        saved.instance_id == current.instance_id && saved.generation == current.generation
+    }) {
+        anyhow::ensure!(
+            saved
+                .identity
+                .as_ref()
+                .is_none_or(|identity| result.identity.as_ref() == Some(identity)),
+            "回执身份改变，未覆盖记录"
+        );
+        if saved.status == "stopped"
+            || saved.status == "cleanup_failed"
+                && !matches!(result.status.as_str(), "stopped" | "cleanup_failed")
+        {
+            return Ok(());
+        }
+    }
+    write_multi_launch_result(&root.join(MULTI_LAUNCH_RESULT_FILE), result)
+}
+
+fn finish_multi_instance_cleanup(
+    root: &Path,
+    instance: &CodexMultiInstance,
+    cleanup: anyhow::Result<()>,
+    absent: impl Fn(&CodexMultiInstance) -> anyhow::Result<bool>,
+) -> anyhow::Result<()> {
+    let verified = cleanup.and_then(|()| {
+        anyhow::ensure!(
+            absent(instance)? && absent(instance)?,
+            "实例进程或端口尚未完全释放"
+        );
+        Ok(())
+    });
+    let result = multi_instance_cleanup_result(instance, &verified);
+    write_multi_instance_result(root, instance, &result)?;
+    verified
+}
+
+fn multi_instance_cleanup_result(
+    instance: &CodexMultiInstance,
+    verified: &anyhow::Result<()>,
+) -> CodexMultiLaunchResult {
+    CodexMultiLaunchResult {
+        instance_id: instance.instance_id.clone(),
+        generation: instance.generation,
+        helper_port: Some(instance.helper_port),
+        identity: instance.identity.clone(),
+        status: if verified.is_ok() {
+            "stopped"
+        } else {
+            "cleanup_failed"
+        }
+        .into(),
+        message: match verified {
+            Ok(()) => "Codex 多开实例已停止，清理完成。".into(),
+            Err(error) => format!("Codex 多开实例清理未完成：{error:#}"),
+        },
+        finished_at_ms: current_timestamp_ms(),
+        debug_port: Some(instance.debug_port),
+        pid: instance
+            .identity
+            .as_ref()
+            .map(|identity| identity.process_id),
+    }
+}
+
+fn wait_for_multi_instance_absence(
+    instance: &CodexMultiInstance,
+    absent: impl Fn(&CodexMultiInstance) -> anyhow::Result<bool>,
+) -> anyhow::Result<()> {
+    wait_for_multi_instance_absence_with_timeout(
+        instance,
+        absent,
+        std::time::Duration::from_secs(10),
+    )
+}
+
+fn wait_for_multi_instance_absence_with_timeout(
+    instance: &CodexMultiInstance,
+    absent: impl Fn(&CodexMultiInstance) -> anyhow::Result<bool>,
+    timeout: std::time::Duration,
+) -> anyhow::Result<()> {
+    let deadline = std::time::Instant::now() + timeout;
+    let mut last_error = None;
+    loop {
+        if std::time::Instant::now() >= deadline {
+            return Err(last_error.unwrap_or_else(|| anyhow::anyhow!("实例进程或端口尚未完全释放")));
+        }
+        match absent(instance).and_then(|first| Ok(first && absent(instance)?)) {
+            Ok(true) if std::time::Instant::now() < deadline => return Ok(()),
+            Ok(_) => {}
+            Err(error)
+                if error.downcast_ref::<std::io::Error>().is_some_and(|error| {
+                    !matches!(
+                        error.kind(),
+                        std::io::ErrorKind::InvalidInput | std::io::ErrorKind::InvalidData
+                    )
+                }) =>
+            {
+                last_error = Some(error)
+            }
+            Err(error) => return Err(error),
+        }
+        let now = std::time::Instant::now();
+        if now >= deadline {
+            return Err(last_error.unwrap_or_else(|| anyhow::anyhow!("实例进程或端口尚未完全释放")));
+        }
+        std::thread::sleep(std::time::Duration::from_millis(100).min(deadline - now));
+    }
+}
+
 /// 读取实例的启动结果；文件不存在或不是合法 JSON 时返回 `None`。
 fn load_multi_launch_result(root: &Path) -> Option<CodexMultiLaunchResult> {
     let contents = std::fs::read_to_string(root.join(MULTI_LAUNCH_RESULT_FILE)).ok()?;
@@ -12527,6 +12975,666 @@ model_reasoning_effort = "high"
         assert!(remained_alive);
     }
 
+    fn stopped_multi_instance_fixture(root: &Path) -> CodexMultiInstance {
+        let data = root.join("user-data");
+        let app = root.join("Codex.app");
+        std::fs::create_dir_all(&data).unwrap();
+        std::fs::create_dir_all(app.join("Contents/MacOS")).unwrap();
+        std::fs::write(app.join("Contents/MacOS/Codex"), "fixture").unwrap();
+        std::fs::write(app.join("Codex.exe"), "fixture").unwrap();
+        let identity = codex_plus_core::multi_worker::CodexInstanceIdentity {
+            instance_id: "fixture-stopped".into(),
+            generation: 7,
+            debug_port: 19401,
+            helper_port: 19402,
+            user_data_dir: data.canonicalize().unwrap(),
+            browser_id: "browser-stopped".into(),
+            process_id: 123,
+            process_birth_id: 456,
+            executable: codex_plus_core::app_paths::build_codex_executable(&app)
+                .canonicalize()
+                .unwrap(),
+        };
+        let result = CodexMultiLaunchResult {
+            instance_id: identity.instance_id.clone(),
+            generation: identity.generation,
+            helper_port: Some(identity.helper_port),
+            identity: Some(identity.clone()),
+            status: "stopped".into(),
+            message: "fixture stopped".into(),
+            finished_at_ms: 8,
+            debug_port: Some(identity.debug_port),
+            pid: Some(identity.process_id),
+        };
+        let instance = CodexMultiInstance {
+            instance_id: identity.instance_id.clone(),
+            generation: identity.generation,
+            identity: Some(identity),
+            profile_id: "fixture".into(),
+            profile_name: "Fixture".into(),
+            pid: Some(124),
+            worker_birth_id: Some(457),
+            debug_port: 19401,
+            helper_port: 19402,
+            status: "starting".into(),
+            running: true,
+            started_at_ms: 7,
+            is_main: false,
+            app_path: Some(app.to_string_lossy().into_owned()),
+            codex_home: None,
+            sqlite_home: None,
+            user_data_dir: Some(data.to_string_lossy().into_owned()),
+            launch_result: Some(result.clone()),
+        };
+        save_multi_instance_manifest(root, &instance).unwrap();
+        write_multi_launch_result(&root.join(MULTI_LAUNCH_RESULT_FILE), &result).unwrap();
+        instance
+    }
+
+    #[test]
+    fn stopped_receipt_reconciliation_persists_and_is_idempotent() {
+        let temp = tempfile::tempdir().unwrap();
+        let original = stopped_multi_instance_fixture(temp.path());
+        let probes = std::cell::Cell::new(0);
+        let current = load_multi_instance_manifest_with_absence(temp.path(), |instance| {
+            assert_eq!(instance.pid, original.pid);
+            probes.set(probes.get() + 1);
+            Ok(true)
+        })
+        .unwrap();
+        assert_eq!(probes.get(), 2);
+        assert_eq!(current.status, "stopped");
+        assert!(!current.running);
+        assert_eq!(current.pid, None);
+        assert_eq!(current.worker_birth_id, None);
+        assert_eq!(current.identity, original.identity);
+        assert_eq!(
+            current.launch_result.as_ref().unwrap().message,
+            "fixture stopped"
+        );
+        let persisted: CodexMultiInstance = serde_json::from_slice(
+            &std::fs::read(multi_instance_manifest_path(temp.path())).unwrap(),
+        )
+        .unwrap();
+        assert_eq!(persisted.status, "stopped");
+        assert_eq!(persisted.pid, None);
+        let again = load_multi_instance_manifest_with_absence(temp.path(), |_| {
+            panic!("already synchronized")
+        })
+        .unwrap();
+        assert_eq!(again.status, "stopped");
+        assert_eq!(multi_instance_snapshot_status(&again, false), "stopped");
+    }
+
+    fn ready_multi_instance_fixture(root: &Path) -> CodexMultiInstance {
+        let mut instance = stopped_multi_instance_fixture(root);
+        instance.launch_result.as_mut().unwrap().status = "ready".into();
+        save_multi_instance_manifest(root, &instance).unwrap();
+        write_multi_launch_result(
+            &root.join(MULTI_LAUNCH_RESULT_FILE),
+            instance.launch_result.as_ref().unwrap(),
+        )
+        .unwrap();
+        instance
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn multi_instance_starting_rejects_stop_without_consuming_ready() {
+        let temp = tempfile::tempdir().unwrap();
+        let mut instance = ready_multi_instance_fixture(temp.path());
+        let ready = instance.launch_result.take().unwrap();
+        instance.identity = None;
+        instance.running = false;
+        instance.pid = Some(std::process::id());
+        let codex_plus_core::watcher::ProcessInstanceState::Running { birth_id, .. } =
+            codex_plus_core::watcher::inspect_process_instance(std::process::id())
+        else {
+            panic!("test process must be alive");
+        };
+        instance.worker_birth_id = birth_id.and_then(|birth| birth.parse().ok());
+        assert!(instance.worker_birth_id.is_some());
+        save_multi_instance_manifest(temp.path(), &instance).unwrap();
+        let receipt_path = temp.path().join(MULTI_LAUNCH_RESULT_FILE);
+        std::fs::write(&receipt_path, "{}").unwrap();
+        assert_eq!(multi_instance_snapshot_status(&instance, false), "starting");
+        assert!(stop_multi_instance_lifecycle(temp.path(), &instance).is_err());
+        assert_eq!(std::fs::read_to_string(&receipt_path).unwrap(), "{}");
+        write_multi_instance_result(temp.path(), &instance, &ready).unwrap();
+        let running = load_multi_instance_manifest(temp.path()).unwrap();
+        assert_eq!(running.launch_result.unwrap().status, "ready");
+        instance.status = "stopped".into();
+        assert!(!multi_instance_is_starting(&instance));
+    }
+
+    #[test]
+    fn multi_instance_absence_wait_retries_reads_but_not_identity_conflicts() {
+        use std::cell::Cell;
+        use std::time::Duration;
+        let temp = tempfile::tempdir().unwrap();
+        let instance = ready_multi_instance_fixture(temp.path());
+        let calls = Cell::new(0);
+        wait_for_multi_instance_absence_with_timeout(
+            &instance,
+            |_| {
+                calls.set(calls.get() + 1);
+                if calls.get() == 1 {
+                    return Err(std::io::Error::from(std::io::ErrorKind::Interrupted).into());
+                }
+                Ok(true)
+            },
+            Duration::from_secs(1),
+        )
+        .unwrap();
+        assert_eq!(calls.get(), 3);
+        let calls = Cell::new(0);
+        let error = wait_for_multi_instance_absence_with_timeout(
+            &instance,
+            |_| {
+                calls.set(calls.get() + 1);
+                Err(std::io::Error::other("last read failure").into())
+            },
+            Duration::from_millis(10),
+        )
+        .unwrap_err();
+        assert!(format!("{error:#}").contains("last read failure"));
+        assert!(calls.get() >= 1);
+        let calls = Cell::new(0);
+        assert!(
+            wait_for_multi_instance_absence_with_timeout(
+                &instance,
+                |_| {
+                    calls.set(calls.get() + 1);
+                    anyhow::bail!("identity conflict")
+                },
+                Duration::from_secs(1)
+            )
+            .is_err()
+        );
+        assert_eq!(calls.get(), 1);
+        let calls = Cell::new(0);
+        wait_for_multi_instance_absence_with_timeout(
+            &instance,
+            |_| {
+                calls.set(calls.get() + 1);
+                Ok(calls.get() > 1)
+            },
+            Duration::from_secs(1),
+        )
+        .unwrap();
+        assert_eq!(calls.get(), 3);
+    }
+
+    #[test]
+    fn multi_instance_missing_receipt_reconciles_only_confirmed_absence_and_is_idempotent() {
+        let temp = tempfile::tempdir().unwrap();
+        let mut instance = ready_multi_instance_fixture(temp.path());
+        instance.launch_result = None;
+        let root = temp.path().join("no-receipt");
+        std::fs::create_dir(&root).unwrap();
+        save_multi_instance_manifest(&root, &instance).unwrap();
+        for failure in [0, 1, 2] {
+            let calls = std::cell::Cell::new(0);
+            let uncertain = load_multi_instance_manifest_with_absence(&root, |_| {
+                calls.set(calls.get() + 1);
+                if failure == 0 {
+                    anyhow::bail!("query denied");
+                }
+                Ok(calls.get() != failure)
+            })
+            .unwrap();
+            assert_ne!(uncertain.status, "stopped");
+            assert!(load_multi_launch_result(&root).is_none());
+        }
+        let final_instance =
+            load_multi_instance_manifest_with_absence(&root, |_| Ok(true)).unwrap();
+        assert_eq!(final_instance.status, "stopped");
+        assert_eq!(final_instance.pid, None);
+        assert!(multi_instance_stopped_receipt_matches(
+            &final_instance,
+            &load_multi_launch_result(&root).unwrap()
+        ));
+        let bytes = std::fs::read(root.join(MULTI_LAUNCH_RESULT_FILE)).unwrap();
+        load_multi_instance_manifest_with_absence(&root, |_| panic!("already synchronized"))
+            .unwrap();
+        assert_eq!(
+            std::fs::read(root.join(MULTI_LAUNCH_RESULT_FILE)).unwrap(),
+            bytes
+        );
+    }
+
+    #[test]
+    fn multi_instance_auto_reconciliation_preserves_ready_or_generation_written_during_probe() {
+        for replace_receipt in [false, true] {
+            let temp = tempfile::tempdir().unwrap();
+            let instance = ready_multi_instance_fixture(temp.path());
+            let root = temp.path().join("no-receipt");
+            std::fs::create_dir(&root).unwrap();
+            save_multi_instance_manifest(&root, &instance).unwrap();
+            let calls = std::cell::Cell::new(0);
+            assert!(
+                load_multi_instance_manifest_with_absence(&root, |_| {
+                    calls.set(calls.get() + 1);
+                    if calls.get() == 2 {
+                        if replace_receipt {
+                            write_multi_launch_result(
+                                &root.join(MULTI_LAUNCH_RESULT_FILE),
+                                instance.launch_result.as_ref().unwrap(),
+                            )?;
+                        } else {
+                            let mut next = instance.clone();
+                            next.generation += 1;
+                            save_multi_instance_manifest(&root, &next)?;
+                        }
+                    }
+                    Ok(true)
+                })
+                .is_err()
+            );
+            let saved: CodexMultiInstance = serde_json::from_slice(
+                &std::fs::read(multi_instance_manifest_path(&root)).unwrap(),
+            )
+            .unwrap();
+            assert_ne!(saved.status, "stopped");
+            if replace_receipt {
+                assert_eq!(load_multi_launch_result(&root).unwrap().status, "ready");
+            } else {
+                assert_eq!(saved.generation, instance.generation + 1);
+            }
+        }
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn multi_instance_missing_receipt_uses_native_birth_scan_and_port_ownership_checks() {
+        let temp = tempfile::tempdir().unwrap();
+        let mut instance = ready_multi_instance_fixture(temp.path());
+        let codex_plus_core::watcher::ProcessInstanceState::Running { birth_id, .. } =
+            codex_plus_core::watcher::inspect_process_instance(std::process::id())
+        else {
+            panic!("test process must be alive");
+        };
+        let birth: u64 = birth_id.unwrap().parse().unwrap();
+        instance.pid = Some(std::process::id());
+        instance.worker_birth_id = Some(birth);
+        let debug = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let helper = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        instance.debug_port = debug.local_addr().unwrap().port();
+        instance.helper_port = helper.local_addr().unwrap().port();
+        let identity = instance.identity.as_mut().unwrap();
+        identity.process_id = std::process::id();
+        identity.process_birth_id = birth + 1;
+        identity.debug_port = instance.debug_port;
+        identity.helper_port = instance.helper_port;
+        instance.launch_result = None;
+        let root = temp.path().join("no-receipt");
+        std::fs::create_dir(&root).unwrap();
+        save_multi_instance_manifest(&root, &instance).unwrap();
+        assert!(multi_instance_is_starting(&CodexMultiInstance {
+            identity: None,
+            ..instance.clone()
+        }));
+        assert_ne!(
+            load_multi_instance_manifest(&root).unwrap().status,
+            "stopped"
+        );
+        instance.worker_birth_id = Some(birth + 1);
+        save_multi_instance_manifest(&root, &instance).unwrap();
+        let stopped = load_multi_instance_manifest(&root).unwrap();
+        assert_eq!(stopped.status, "stopped");
+        assert!(
+            codex_plus_core::multi_worker::codex_process_generation_exited(
+                std::process::id(),
+                Some(birth + 1)
+            )
+            .unwrap()
+        );
+        assert!(
+            !codex_plus_core::multi_worker::codex_process_generation_exited(
+                std::process::id(),
+                Some(birth)
+            )
+            .unwrap()
+        );
+        assert!(debug.local_addr().is_ok() && helper.local_addr().is_ok());
+    }
+
+    #[test]
+    fn multi_instance_auto_reconciliation_closes_valid_receipts_but_keeps_main_and_unreadable_records()
+    {
+        for status in ["ready", "ready_degraded", "failed", "cleanup_failed"] {
+            let temp = tempfile::tempdir().unwrap();
+            let mut instance = ready_multi_instance_fixture(temp.path());
+            instance.launch_result.as_mut().unwrap().status = status.into();
+            write_multi_launch_result(
+                &temp.path().join(MULTI_LAUNCH_RESULT_FILE),
+                instance.launch_result.as_ref().unwrap(),
+            )
+            .unwrap();
+            let stopped =
+                load_multi_instance_manifest_with_absence(temp.path(), |_| Ok(true)).unwrap();
+            assert_eq!(stopped.status, "stopped");
+            assert_eq!(
+                load_multi_launch_result(temp.path()).unwrap().status,
+                "stopped"
+            );
+        }
+        let temp = tempfile::tempdir().unwrap();
+        let instance = ready_multi_instance_fixture(temp.path());
+        for invalid in ["corrupt", "unreadable", "main"] {
+            let root = temp.path().join(invalid);
+            std::fs::create_dir(&root).unwrap();
+            let mut saved = instance.clone();
+            saved.launch_result = None;
+            saved.is_main = invalid == "main";
+            save_multi_instance_manifest(&root, &saved).unwrap();
+            if invalid == "corrupt" {
+                std::fs::write(root.join(MULTI_LAUNCH_RESULT_FILE), "{").unwrap();
+            } else if invalid == "unreadable" {
+                std::fs::create_dir(root.join(MULTI_LAUNCH_RESULT_FILE)).unwrap();
+            }
+            let current = load_multi_instance_manifest_with_absence(&root, |_| {
+                panic!("uncertain receipt or main instance must not be reconciled")
+            })
+            .unwrap();
+            assert_ne!(current.status, "stopped");
+        }
+    }
+
+    #[test]
+    fn multi_instance_lifecycle_stop_and_natural_close_write_read_final_receipt() {
+        for worker_has_exited in [false, true] {
+            let temp = tempfile::tempdir().unwrap();
+            let instance = ready_multi_instance_fixture(temp.path());
+            assert_eq!(multi_instance_snapshot_status(&instance, false), "unknown");
+            finish_multi_instance_cleanup(temp.path(), &instance, Ok(()), |_| Ok(true)).unwrap();
+            let receipt = load_multi_launch_result(temp.path()).unwrap();
+            assert_eq!(receipt.status, "stopped");
+            assert_eq!(receipt.generation, instance.generation);
+            assert_eq!(receipt.identity, instance.identity);
+            let pending =
+                load_multi_instance_manifest_with_absence(temp.path(), |_| Ok(worker_has_exited))
+                    .unwrap();
+            assert_eq!(
+                pending.pid,
+                if worker_has_exited {
+                    None
+                } else {
+                    instance.pid
+                }
+            );
+            let final_instance =
+                load_multi_instance_manifest_with_absence(temp.path(), |_| Ok(true)).unwrap();
+            assert_eq!(final_instance.status, "stopped");
+            assert_eq!(final_instance.pid, None);
+            assert_eq!(final_instance.worker_birth_id, None);
+            let reloaded = load_multi_instance_manifest_with_absence(temp.path(), |_| {
+                panic!("already cleared")
+            })
+            .unwrap();
+            assert_eq!(multi_instance_snapshot_status(&reloaded, false), "stopped");
+        }
+    }
+
+    #[test]
+    fn multi_instance_lifecycle_cleanup_failure_never_writes_stopped_and_can_retry() {
+        for failure in ["shutdown", "occupied", "query"] {
+            let temp = tempfile::tempdir().unwrap();
+            let instance = ready_multi_instance_fixture(temp.path());
+            let cleanup = if failure == "shutdown" {
+                Err(anyhow::anyhow!("shutdown failed"))
+            } else {
+                Ok(())
+            };
+            assert!(
+                finish_multi_instance_cleanup(temp.path(), &instance, cleanup, |_| {
+                    if failure == "shutdown" {
+                        panic!("failed shutdown must not be promoted");
+                    }
+                    if failure == "query" {
+                        anyhow::bail!("process query failed");
+                    }
+                    Ok(false)
+                })
+                .is_err()
+            );
+            let receipt = load_multi_launch_result(temp.path()).unwrap();
+            assert_eq!(receipt.status, "cleanup_failed");
+            assert_eq!(receipt.identity, instance.identity);
+            let uncertain =
+                load_multi_instance_manifest_with_absence(temp.path(), |_| Ok(false)).unwrap();
+            assert_eq!(uncertain.pid, instance.pid);
+            assert_eq!(multi_instance_snapshot_status(&uncertain, false), "unknown");
+            finish_multi_instance_cleanup(temp.path(), &uncertain, Ok(()), |_| Ok(true)).unwrap();
+            let final_instance =
+                load_multi_instance_manifest_with_absence(temp.path(), |_| Ok(true)).unwrap();
+            assert_eq!(final_instance.status, "stopped");
+            assert_eq!(final_instance.pid, None);
+        }
+    }
+
+    #[test]
+    fn multi_instance_lifecycle_unready_and_legacy_records_require_explicit_verified_cleanup() {
+        for generation in [0, 7] {
+            let temp = tempfile::tempdir().unwrap();
+            let mut instance = ready_multi_instance_fixture(temp.path());
+            instance.generation = generation;
+            instance.identity = None;
+            instance.launch_result = None;
+            save_multi_instance_manifest(temp.path(), &instance).unwrap();
+            let mut previous_receipt = load_multi_launch_result(temp.path()).unwrap();
+            previous_receipt.generation = generation.saturating_add(1);
+            write_multi_launch_result(
+                &temp.path().join(MULTI_LAUNCH_RESULT_FILE),
+                &previous_receipt,
+            )
+            .unwrap();
+            let old = load_multi_instance_manifest_with_absence(temp.path(), |_| {
+                panic!("no stopped receipt")
+            })
+            .unwrap();
+            assert_eq!(multi_instance_snapshot_status(&old, false), "unknown");
+            assert!(
+                finish_multi_instance_cleanup(temp.path(), &instance, Ok(()), |_| Ok(false))
+                    .is_err()
+            );
+            assert_eq!(
+                load_multi_launch_result(temp.path()).unwrap().status,
+                "cleanup_failed"
+            );
+            finish_multi_instance_cleanup(temp.path(), &instance, Ok(()), |_| Ok(true)).unwrap();
+            let final_instance =
+                load_multi_instance_manifest_with_absence(temp.path(), |_| Ok(true)).unwrap();
+            assert_eq!(final_instance.status, "stopped");
+            assert_eq!(final_instance.pid, None);
+        }
+    }
+
+    #[test]
+    fn multi_instance_lifecycle_writer_rejects_changed_identity_and_new_generation() {
+        for change in ["generation", "identity", "paths", "receipt"] {
+            let temp = tempfile::tempdir().unwrap();
+            let original = ready_multi_instance_fixture(temp.path());
+            let mut replacement = original.clone();
+            match change {
+                "generation" => {
+                    replacement.generation += 1;
+                    replacement.identity.as_mut().unwrap().generation += 1;
+                    replacement.launch_result.as_mut().unwrap().generation += 1;
+                    replacement
+                        .launch_result
+                        .as_mut()
+                        .unwrap()
+                        .identity
+                        .as_mut()
+                        .unwrap()
+                        .generation += 1;
+                }
+                "identity" => replacement.identity.as_mut().unwrap().process_birth_id += 1,
+                "paths" => replacement.user_data_dir = Some(temp.path().display().to_string()),
+                _ => {
+                    replacement
+                        .launch_result
+                        .as_mut()
+                        .unwrap()
+                        .identity
+                        .as_mut()
+                        .unwrap()
+                        .browser_id = "replacement".into()
+                }
+            }
+            save_multi_instance_manifest(temp.path(), &replacement).unwrap();
+            write_multi_launch_result(
+                &temp.path().join(MULTI_LAUNCH_RESULT_FILE),
+                replacement.launch_result.as_ref().unwrap(),
+            )
+            .unwrap();
+            let manifest = std::fs::read(multi_instance_manifest_path(temp.path())).unwrap();
+            let receipt = std::fs::read(temp.path().join(MULTI_LAUNCH_RESULT_FILE)).unwrap();
+            assert!(
+                finish_multi_instance_cleanup(temp.path(), &original, Ok(()), |_| Ok(true))
+                    .is_err()
+            );
+            assert_eq!(
+                std::fs::read(multi_instance_manifest_path(temp.path())).unwrap(),
+                manifest
+            );
+            assert_eq!(
+                std::fs::read(temp.path().join(MULTI_LAUNCH_RESULT_FILE)).unwrap(),
+                receipt
+            );
+        }
+    }
+
+    #[test]
+    fn multi_instance_lifecycle_terminal_receipt_is_not_downgraded_by_delayed_ready() {
+        let temp = tempfile::tempdir().unwrap();
+        let instance = ready_multi_instance_fixture(temp.path());
+        finish_multi_instance_cleanup(temp.path(), &instance, Ok(()), |_| Ok(true)).unwrap();
+        write_multi_instance_result(
+            temp.path(),
+            &instance,
+            instance.launch_result.as_ref().unwrap(),
+        )
+        .unwrap();
+        assert_eq!(
+            load_multi_launch_result(temp.path()).unwrap().status,
+            "stopped"
+        );
+    }
+
+    #[test]
+    fn stopped_receipt_reconciliation_keeps_uncertain_or_changed_instances() {
+        for failed_probe in [0, 1, 2] {
+            let temp = tempfile::tempdir().unwrap();
+            stopped_multi_instance_fixture(temp.path());
+            let original = std::fs::read(multi_instance_manifest_path(temp.path())).unwrap();
+            let probes = std::cell::Cell::new(0);
+            let current = load_multi_instance_manifest_with_absence(temp.path(), |_| {
+                probes.set(probes.get() + 1);
+                if failed_probe == 0 {
+                    anyhow::bail!("query unavailable");
+                }
+                Ok(probes.get() != failed_probe)
+            })
+            .unwrap();
+            assert_eq!(current.status, "starting");
+            assert_eq!(current.pid, Some(124));
+            assert_eq!(multi_instance_snapshot_status(&current, false), "unknown");
+            assert_eq!(
+                std::fs::read(multi_instance_manifest_path(temp.path())).unwrap(),
+                original
+            );
+        }
+    }
+
+    #[test]
+    fn stopped_receipt_reconciliation_rejects_mismatched_or_incomplete_evidence() {
+        let temp = tempfile::tempdir().unwrap();
+        let original = stopped_multi_instance_fixture(temp.path());
+        let receipt = original.launch_result.clone().unwrap();
+        assert!(multi_instance_stopped_receipt_matches(&original, &receipt));
+        let mut variants = Vec::new();
+        let mut result = receipt.clone();
+        result.generation += 1;
+        variants.push(result);
+        let mut result = receipt.clone();
+        result.instance_id = "neighbor".into();
+        variants.push(result);
+        let mut result = receipt.clone();
+        result.debug_port = Some(19403);
+        variants.push(result);
+        let mut result = receipt.clone();
+        result.helper_port = None;
+        variants.push(result);
+        let mut result = receipt.clone();
+        result.pid = None;
+        variants.push(result);
+        let mut result = receipt.clone();
+        result.identity = None;
+        variants.push(result);
+        let mut result = receipt.clone();
+        result.identity.as_mut().unwrap().process_birth_id += 1;
+        variants.push(result);
+        let mut result = receipt;
+        result.identity.as_mut().unwrap().user_data_dir = temp.path().into();
+        variants.push(result);
+        for result in variants {
+            assert!(!multi_instance_stopped_receipt_matches(&original, &result));
+            write_multi_launch_result(&temp.path().join(MULTI_LAUNCH_RESULT_FILE), &result)
+                .unwrap();
+            let current = load_multi_instance_manifest_with_absence(temp.path(), |_| {
+                panic!("must not probe mismatched receipt")
+            })
+            .unwrap();
+            assert_eq!(current.status, "starting");
+            assert_eq!(current.pid, original.pid);
+        }
+    }
+
+    #[test]
+    fn stopped_receipt_reconciliation_does_not_overwrite_replaced_files() {
+        for replace_receipt in [false, true] {
+            let temp = tempfile::tempdir().unwrap();
+            let original = stopped_multi_instance_fixture(temp.path());
+            let probes = std::cell::Cell::new(0);
+            let loaded = load_multi_instance_manifest_with_absence(temp.path(), |_| {
+                probes.set(probes.get() + 1);
+                if probes.get() == 2 {
+                    if replace_receipt {
+                        let mut result = original.launch_result.clone().unwrap();
+                        result.generation += 1;
+                        write_multi_launch_result(
+                            &temp.path().join(MULTI_LAUNCH_RESULT_FILE),
+                            &result,
+                        )?;
+                    } else {
+                        let mut next = original.clone();
+                        next.generation += 1;
+                        save_multi_instance_manifest(temp.path(), &next)?;
+                    }
+                }
+                Ok(true)
+            });
+            assert!(loaded.is_err());
+            let saved: CodexMultiInstance = serde_json::from_slice(
+                &std::fs::read(multi_instance_manifest_path(temp.path())).unwrap(),
+            )
+            .unwrap();
+            assert_eq!(saved.status, "starting");
+            assert_eq!(saved.pid, original.pid);
+            assert_eq!(
+                saved.generation,
+                original.generation + u64::from(!replace_receipt)
+            );
+            let result = load_multi_launch_result(temp.path()).unwrap();
+            assert_eq!(
+                result.generation,
+                original.generation + u64::from(replace_receipt)
+            );
+        }
+    }
+
     // 多开在 Windows 上曾经「窗口没出现、列表却显示运行中」：现在状态由
     // worker 落盘的启动结果 + 端口判活共同决定，两者都要有测试守住。
     #[test]
diff --git a/apps/codex-plus-manager/src/App.tsx b/apps/codex-plus-manager/src/App.tsx
index ca9071522..0aec087d8 100644
--- a/apps/codex-plus-manager/src/App.tsx
+++ b/apps/codex-plus-manager/src/App.tsx
@@ -289,6 +289,8 @@ import {
 import { subscribeLanguage, getLanguage, t, tf, toggleLanguage } from "@/i18n";
 import { vlmTestTranslation } from "./vlm-test-translation";
 import {
+  multiLaunchInstanceCanRestart,
+  multiLaunchInstanceCanStop,
   multiLaunchInstanceFailure,
   multiLaunchInstanceLabel as formatMultiLaunchInstanceLabel,
   multiLaunchInstanceRunning,
@@ -2797,7 +2799,7 @@ export function App() {
         // 界面要给出「启动失败 + 原因」，只留运行中的会让它彻底消失。
         setMultiLaunchInstances(
           Array.isArray(result.instances)
-            ? result.instances.filter((instance) => multiLaunchInstanceRunning(instance) || Boolean(multiLaunchInstanceFailure(instance)))
+            ? result.instances.filter((instance) => multiLaunchInstanceStatus(instance) !== "stopped")
             : [],
         );
         if (!silent && !isSuccessStatus(result.status)) showNotice(t("当前运行实例"), result.message, result.status);
@@ -7557,7 +7559,7 @@ function CodexMultiLaunchScreen({
               <div className="multi-launch-instance-list">
                 {actions.multiLaunchInstances.map((instance) => {
                   const status = multiLaunchInstanceStatus(instance);
-                  const running = multiLaunchInstanceRunning(instance);
+                  const canStop = multiLaunchInstanceCanStop(instance);
                   const pending = actions.multiLaunchActionPending === instance.instanceId;
                   const label = formatMultiLaunchInstanceLabel(instance, { main: t("主 Codex"), fallback: t("Codex 实例") });
                   // 启动失败的原因必须让用户看得见：Windows 上多开曾经完全不吭声。
@@ -7567,7 +7569,7 @@ function CodexMultiLaunchScreen({
                     typeof instance.pid === "number" ? `PID ${instance.pid}` : "",
                     typeof instance.debugPort === "number" ? `CDP ${instance.debugPort}` : "",
                     typeof instance.helperPort === "number" ? `API ${instance.helperPort}` : "",
-                    failure ? `${t("启动失败")}：${failure}` : "",
+                    failure ? `${instance.launchResult?.status === "cleanup_failed" ? t("失败") : t("启动失败")}：${failure}` : "",
                   ].filter(Boolean).join(" · ");
                   return (
                     <div className="multi-launch-instance-card" data-instance-id={instance.instanceId} key={instance.instanceId}>
@@ -7579,7 +7581,7 @@ function CodexMultiLaunchScreen({
                       <UiBadge className={`multi-launch-instance-status ${statusClass(status)}`} variant="secondary">{statusLabel(status)}</UiBadge>
                       <span className="relay-card-actions">
                         <Button
-                          disabled={pending}
+                          disabled={!multiLaunchInstanceCanRestart(instance) || pending}
                           onClick={() => void actions.restartMultiLaunchInstance(instance)}
                           size="sm"
                           title={t("重启此 Codex 实例")}
@@ -7588,10 +7590,10 @@ function CodexMultiLaunchScreen({
                           {pending ? t("处理中") : t("重启")}
                         </Button>
                         <Button
-                          disabled={!running || pending}
+                          disabled={!canStop || pending}
                           onClick={() => void actions.stopMultiLaunchInstance(instance)}
                           size="sm"
-                          title={running ? t("结束此 Codex 实例") : t("实例当前未运行")}
+                          title={canStop ? t("结束此 Codex 实例") : t("实例当前未运行")}
                           variant="secondary"
                         >
                           <PowerOff className="h-4 w-4" />
diff --git a/apps/codex-plus-manager/src/multi-launch-model.test.ts b/apps/codex-plus-manager/src/multi-launch-model.test.ts
index f1aaa0c25..640716bfa 100644
--- a/apps/codex-plus-manager/src/multi-launch-model.test.ts
+++ b/apps/codex-plus-manager/src/multi-launch-model.test.ts
@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
+  multiLaunchInstanceCanRestart,
+  multiLaunchInstanceCanStop,
   multiLaunchInstanceFailure,
   multiLaunchInstanceLabel,
   multiLaunchInstanceRunning,
@@ -16,6 +18,17 @@ const instance = (patch: Partial<MultiLaunchInstance> = {}): MultiLaunchInstance
 });
 
 describe("Codex 多开运行实例模型", () => {
+  it("启动期间禁止结束和重启，其他状态保留原有操作", () => {
+    const starting = instance({ status: " STARTING ", running: true });
+    assert.equal(multiLaunchInstanceCanStop(starting), false);
+    assert.equal(multiLaunchInstanceCanRestart(starting), false);
+    for (const status of ["running", "unknown", "failed"]) {
+      assert.equal(multiLaunchInstanceCanStop(instance({ status })), true);
+      assert.equal(multiLaunchInstanceCanRestart(instance({ status })), true);
+    }
+    assert.equal(multiLaunchInstanceCanStop(instance({ status: "stopped" })), false);
+    assert.equal(multiLaunchInstanceCanRestart(instance({ status: "stopped" })), true);
+  });
   it("主 Codex 优先使用主实例标签", () => {
     assert.equal(multiLaunchInstanceLabel(instance({ isMain: true, profileName: "旧名称" })), "主 Codex");
   });
@@ -28,7 +41,7 @@ describe("Codex 多开运行实例模型", () => {
 
   it("状态归一化并识别可结束的运行态", () => {
     assert.equal(multiLaunchInstanceStatus(instance({ status: "  RUNNING " })), "running");
-    assert.equal(multiLaunchInstanceRunning(instance({ status: "starting" })), true);
+    assert.equal(multiLaunchInstanceRunning(instance({ status: "starting" })), false);
     assert.equal(multiLaunchInstanceRunning(instance({ status: "running_degraded" })), true);
     assert.equal(multiLaunchInstanceRunning(instance({ status: "stopped", running: true })), true);
     assert.equal(multiLaunchInstanceRunning(instance({ status: "stopped" })), false);
@@ -42,6 +55,13 @@ describe("Codex 多开运行实例模型", () => {
       launchResult: { status: "failed", message: "调试端口 9456 未就绪" },
     });
     assert.equal(multiLaunchInstanceFailure(failed), "调试端口 9456 未就绪");
+    assert.equal(
+      multiLaunchInstanceFailure(instance({
+        status: "unknown", running: false,
+        launchResult: { status: "cleanup_failed", message: "实例清理未完成" },
+      })),
+      "实例清理未完成",
+    );
 
     assert.equal(
       multiLaunchInstanceFailure(instance({ status: "failed", running: false, launchResult: { status: "failed" } })),
diff --git a/apps/codex-plus-manager/src/multi-launch-model.ts b/apps/codex-plus-manager/src/multi-launch-model.ts
index f1359a7d3..954c4ac0d 100644
--- a/apps/codex-plus-manager/src/multi-launch-model.ts
+++ b/apps/codex-plus-manager/src/multi-launch-model.ts
@@ -38,7 +38,16 @@ export function multiLaunchInstanceStatus(instance: MultiLaunchInstance): string
 
 export function multiLaunchInstanceRunning(instance: MultiLaunchInstance): boolean {
   if (typeof instance.running === "boolean") return instance.running;
-  return ["running", "running_degraded", "starting", "ready", "connected", "ok"].includes(multiLaunchInstanceStatus(instance));
+  return ["running", "running_degraded", "ready", "connected", "ok"].includes(multiLaunchInstanceStatus(instance));
+}
+
+export function multiLaunchInstanceCanStop(instance: MultiLaunchInstance): boolean {
+  const status = multiLaunchInstanceStatus(instance);
+  return status !== "starting" && (multiLaunchInstanceRunning(instance) || status === "unknown" || status === "failed");
+}
+
+export function multiLaunchInstanceCanRestart(instance: MultiLaunchInstance): boolean {
+  return multiLaunchInstanceStatus(instance) !== "starting";
 }
 
 /**
@@ -50,7 +59,7 @@ export function multiLaunchInstanceRunning(instance: MultiLaunchInstance): boole
 export function multiLaunchInstanceFailure(instance: MultiLaunchInstance): string {
   if (multiLaunchInstanceRunning(instance)) return "";
   const result = instance.launchResult;
-  if (!result || result.status !== "failed") return "";
+  if (!result || !["failed", "cleanup_failed"].includes(result.status ?? "")) return "";
   return result.message?.trim() || "Codex 实例启动失败，原因未记录。";
 }
 
diff --git a/crates/codex-plus-core/src/multi_worker.rs b/crates/codex-plus-core/src/multi_worker.rs
index 342dbed22..90bb6a955 100644
--- a/crates/codex-plus-core/src/multi_worker.rs
+++ b/crates/codex-plus-core/src/multi_worker.rs
@@ -22,6 +22,17 @@ pub struct CodexInstanceIdentity {
     pub executable: PathBuf,
 }
 
+pub fn lock_instance_lifecycle(root: &Path) -> anyhow::Result<std::fs::File> {
+    let file = std::fs::OpenOptions::new()
+        .create(true)
+        .truncate(false)
+        .read(true)
+        .write(true)
+        .open(root.join("lifecycle.lock"))?;
+    fs2::FileExt::lock_exclusive(&file)?;
+    Ok(file)
+}
+
 #[cfg(any(windows, target_os = "macos", target_os = "linux", test))]
 fn valid_stop_identity(identity: &CodexInstanceIdentity) -> bool {
     !identity.instance_id.trim().is_empty()
@@ -306,9 +317,14 @@ fn unix_birth_token(pid: u32) -> Option<u64> {
     else {
         return None;
     };
-    Some(birth.bytes().fold(0xcbf29ce484222325_u64, |hash, byte| {
+    Some(unix_birth_hash(&birth))
+}
+
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+fn unix_birth_hash(birth: &str) -> u64 {
+    birth.bytes().fold(0xcbf29ce484222325_u64, |hash, byte| {
         (hash ^ byte as u64).wrapping_mul(0x100000001b3)
-    }))
+    })
 }
 
 #[cfg(any(target_os = "macos", target_os = "linux"))]
@@ -556,6 +572,422 @@ pub(crate) fn worker_identity_matches(
     expected == actual
 }
 
+#[cfg(windows)]
+pub fn codex_process_generation_exited(
+    pid: u32,
+    expected_birth: Option<u64>,
+) -> anyhow::Result<bool> {
+    process_generation_exited_with(
+        pid,
+        expected_birth,
+        crate::windows_integration::process_lifetime,
+    )
+}
+
+#[cfg(any(windows, test))]
+fn process_generation_exited_with(
+    pid: u32,
+    expected_birth: Option<u64>,
+    query: impl FnOnce(u32) -> anyhow::Result<Option<(u64, bool)>>,
+) -> anyhow::Result<bool> {
+    if pid == 0 || expected_birth == Some(0) {
+        return Ok(false);
+    }
+    let Some((birth, exited)) = query(pid)? else {
+        return Ok(true);
+    };
+    anyhow::ensure!(birth != 0, "无法确认进程创建身份");
+    Ok(exited || expected_birth.is_some_and(|expected| expected != birth))
+}
+
+#[cfg(target_os = "macos")]
+pub fn codex_process_generation_exited(
+    pid: u32,
+    expected_birth: Option<u64>,
+) -> anyhow::Result<bool> {
+    use crate::watcher::{ProcessInstanceState, inspect_process_instance};
+    if pid == 0 || expected_birth == Some(0) {
+        return Ok(false);
+    }
+    match inspect_process_instance(pid) {
+        ProcessInstanceState::NotRunning => Ok(true),
+        ProcessInstanceState::Running {
+            birth_id: Some(birth),
+            ..
+        } => Ok(expected_birth.is_some_and(|expected| expected != unix_birth_hash(&birth))),
+        _ => anyhow::bail!("无法确认进程是否已退出"),
+    }
+}
+
+#[cfg(windows)]
+pub fn codex_user_data_is_absent(
+    executable: &Path,
+    user_data_dir: &Path,
+    debug_port: u16,
+    helper_port: u16,
+) -> anyhow::Result<bool> {
+    use crate::windows_integration::bounded_process_snapshot;
+    anyhow::ensure!(
+        debug_port != 0 && helper_port != 0 && debug_port != helper_port,
+        "实例端口无效"
+    );
+    anyhow::ensure!(
+        executable.is_absolute() && user_data_dir.is_absolute(),
+        "多开路径必须是绝对路径"
+    );
+    let resolved_executable = scan_image_path_with(executable, |path| path.canonicalize())?;
+    let user_data_dir = user_data_dir.canonicalize()?;
+    let name = resolved_executable
+        .as_deref()
+        .unwrap_or(executable)
+        .file_name()
+        .ok_or_else(|| anyhow::anyhow!("缺少桌面程序名"))?;
+    for entry in bounded_process_snapshot(32768)? {
+        if !entry.exe_file.eq_ignore_ascii_case(&name.to_string_lossy()) {
+            continue;
+        }
+        if windows_process_uses_user_data(entry.process_id, executable, &user_data_dir)? {
+            return Ok(false);
+        }
+    }
+    loopback_ports_are_free_with(
+        debug_port,
+        helper_port,
+        |host, port| std::net::TcpListener::bind((host, port)),
+        |port| {
+            let owners = crate::windows_integration::loopback_listener_process_ids(port)?;
+            anyhow::ensure!(!owners.is_empty(), "占用端口的进程归属尚未确认");
+            for pid in &owners {
+                if windows_process_uses_user_data(*pid, executable, &user_data_dir)? {
+                    return Ok(false);
+                }
+            }
+            anyhow::ensure!(
+                crate::windows_integration::loopback_listener_process_ids(port)? == owners,
+                "端口归属在核验期间改变"
+            );
+            Ok(true)
+        },
+    )
+}
+
+#[cfg(any(windows, target_os = "macos", test))]
+fn process_read_or_exited<T>(
+    read: anyhow::Result<T>,
+    exited: impl FnOnce() -> anyhow::Result<bool>,
+) -> anyhow::Result<Option<T>> {
+    match read {
+        Ok(value) => Ok(Some(value)),
+        Err(_) if matches!(exited(), Ok(true)) => Ok(None),
+        Err(error) => Err(std::io::Error::other(error).into()),
+    }
+}
+
+#[cfg(windows)]
+fn scan_image_path_with(
+    path: &Path,
+    resolve: impl FnOnce(&Path) -> std::io::Result<PathBuf>,
+) -> std::io::Result<Option<PathBuf>> {
+    use std::io::{Error, ErrorKind};
+    if !path.is_absolute() {
+        return Err(Error::from(ErrorKind::InvalidInput));
+    }
+    // 映像允许安装路径消失或权限受限；数据目录仍由调用方严格解析。
+    match resolve(path) {
+        Ok(resolved) => Ok(Some(resolved)),
+        Err(error) if matches!(error.kind(), ErrorKind::NotFound | ErrorKind::PermissionDenied) => {
+            Ok(None)
+        }
+        Err(error) => Err(error),
+    }
+}
+
+#[cfg(windows)]
+fn scan_images_match_with(
+    actual: &Path,
+    expected: &Path,
+    mut resolve: impl FnMut(&Path) -> std::io::Result<PathBuf>,
+) -> std::io::Result<bool> {
+    let resolved_actual = scan_image_path_with(actual, &mut resolve)?;
+    let resolved_expected = scan_image_path_with(expected, resolve)?;
+    Ok(match (resolved_actual, resolved_expected) {
+        (Some(actual), Some(expected)) => windows_process_tree::same_resolved_path(&actual, &expected),
+        _ => windows_process_tree::same_resolved_path(actual, expected),
+    })
+}
+
+#[cfg(windows)]
+fn windows_process_uses_user_data(
+    pid: u32,
+    executable: &Path,
+    user_data: &Path,
+) -> anyhow::Result<bool> {
+    use crate::windows_integration::{VerifiedStopProcess, process_lifetime};
+    let captured = process_read_or_exited(VerifiedStopProcess::capture(pid, false), || {
+        Ok(process_lifetime(pid)?.is_none_or(|(_, exited)| exited))
+    })?;
+    let Some(Some(process)) = captured else {
+        return Ok(false);
+    };
+    if !process.is_alive()? {
+        return Ok(false);
+    }
+    let Some(image_matches) = process_read_or_exited(
+        process.image().and_then(|image| {
+            Ok(scan_images_match_with(&image, executable, |path| path.canonicalize())?)
+        }),
+        || Ok(!process.is_alive()?),
+    )?
+    else {
+        return Ok(false);
+    };
+    if !image_matches {
+        return Ok(false);
+    }
+    let Some(arguments) = process_read_or_exited(process.arguments(), || Ok(!process.is_alive()?))?
+    else {
+        return Ok(false);
+    };
+    arguments_user_data_matches(&arguments, user_data)
+}
+
+#[cfg(target_os = "macos")]
+pub fn codex_user_data_is_absent(
+    executable: &Path,
+    user_data_dir: &Path,
+    debug_port: u16,
+    helper_port: u16,
+) -> anyhow::Result<bool> {
+    anyhow::ensure!(
+        debug_port != 0 && helper_port != 0 && debug_port != helper_port,
+        "实例端口无效"
+    );
+    anyhow::ensure!(
+        executable.is_absolute() && user_data_dir.is_absolute(),
+        "多开路径必须是绝对路径"
+    );
+    let executable = executable.canonicalize()?;
+    let user_data_dir = user_data_dir.canonicalize()?;
+    let snapshot = macos_process_snapshot()?;
+    if !macos_snapshot_user_data_is_absent_with(
+        &snapshot,
+        &executable,
+        &user_data_dir,
+        macos_process_arguments,
+        macos_process_snapshot,
+    )? {
+        return Ok(false);
+    }
+    loopback_ports_are_free_with(
+        debug_port,
+        helper_port,
+        |host, port| std::net::TcpListener::bind((host, port)),
+        |port| {
+            let owners = macos_listener_process_ids(port)?;
+            for pid in &owners {
+                let image = snapshot
+                    .get(pid)
+                    .ok_or_else(|| std::io::Error::other("监听进程不在本次快照中"))?;
+                if !macos_image_is_candidate(image, &executable) {
+                    continue;
+                }
+                let arguments = process_read_or_exited(macos_process_arguments(*pid), || {
+                    Ok(!macos_process_snapshot()?.contains_key(pid))
+                })?;
+                if let Some(arguments) = arguments
+                    && arguments_user_data_matches(&arguments, &user_data_dir)?
+                {
+                    return Ok(false);
+                }
+            }
+            anyhow::ensure!(
+                macos_listener_process_ids(port)? == owners,
+                "端口归属在核验期间改变"
+            );
+            Ok(true)
+        },
+    )
+}
+
+#[cfg(target_os = "macos")]
+fn macos_process_snapshot() -> anyhow::Result<std::collections::BTreeMap<u32, PathBuf>> {
+    let output = std::process::Command::new("ps")
+        .args(["-axww", "-o", "pid=,comm="])
+        .output()?;
+    if !output.status.success() {
+        return Err(std::io::Error::other("无法读取进程快照").into());
+    }
+    parse_macos_process_snapshot(&output.stdout)
+}
+
+#[cfg(any(target_os = "macos", test))]
+fn parse_macos_process_snapshot(
+    bytes: &[u8],
+) -> anyhow::Result<std::collections::BTreeMap<u32, PathBuf>> {
+    anyhow::ensure!(
+        bytes.len() <= 8 * 1024 * 1024 && bytes.ends_with(b"\n"),
+        "进程快照截断或过大"
+    );
+    let snapshot = std::str::from_utf8(bytes)?;
+    anyhow::ensure!(
+        !snapshot.trim().is_empty() && snapshot.lines().count() <= 32768,
+        "进程快照无效"
+    );
+    let mut processes = std::collections::BTreeMap::new();
+    for line in snapshot.lines() {
+        let (pid, image) = line
+            .trim()
+            .split_once(char::is_whitespace)
+            .ok_or_else(|| anyhow::anyhow!("进程快照缺少映像"))?;
+        let pid = pid.parse::<u32>()?;
+        anyhow::ensure!(!image.trim().is_empty(), "进程快照缺少映像");
+        anyhow::ensure!(
+            processes.insert(pid, PathBuf::from(image.trim())).is_none(),
+            "进程快照含重复 PID"
+        );
+    }
+    Ok(processes)
+}
+
+#[cfg(any(target_os = "macos", test))]
+fn macos_image_is_candidate(image: &Path, executable: &Path) -> bool {
+    image == executable
+        || executable
+            .parent()
+            .and_then(Path::parent)
+            .is_some_and(|contents| image.starts_with(contents.join("Frameworks")))
+}
+
+#[cfg(any(target_os = "macos", test))]
+fn macos_snapshot_user_data_is_absent_with(
+    snapshot: &std::collections::BTreeMap<u32, PathBuf>,
+    executable: &Path,
+    user_data: &Path,
+    mut arguments: impl FnMut(u32) -> anyhow::Result<Vec<String>>,
+    refresh: impl FnOnce() -> anyhow::Result<std::collections::BTreeMap<u32, PathBuf>>,
+) -> anyhow::Result<bool> {
+    let mut failures = Vec::new();
+    for (pid, image) in snapshot {
+        if !macos_image_is_candidate(image, executable) {
+            continue;
+        }
+        let args = match arguments(*pid) {
+            Ok(args) => args,
+            Err(error) => {
+                failures.push((*pid, error));
+                continue;
+            }
+        };
+        match arguments_user_data_matches(&args, user_data) {
+            Ok(true) => return Ok(false),
+            Ok(false) => {}
+            Err(error) if error.is::<std::io::Error>() => failures.push((*pid, error)),
+            Err(error) => return Err(error),
+        }
+    }
+    if !failures.is_empty() {
+        let current = refresh()?;
+        for (pid, error) in failures {
+            if current.contains_key(&pid) {
+                return Err(std::io::Error::other(error).into());
+            }
+        }
+    }
+    Ok(true)
+}
+
+#[cfg(target_os = "macos")]
+fn macos_listener_process_ids(port: u16) -> anyhow::Result<Vec<u32>> {
+    let output = std::process::Command::new("/usr/sbin/lsof")
+        .args(["-nP", "-a", &format!("-iTCP:{port}"), "-sTCP:LISTEN", "-t"])
+        .output()?;
+    if !output.status.success() {
+        return Err(std::io::Error::other("无法查询监听进程归属").into());
+    }
+    parse_macos_listener_process_ids(&output.stdout)
+}
+
+#[cfg(any(target_os = "macos", test))]
+fn parse_macos_listener_process_ids(bytes: &[u8]) -> anyhow::Result<Vec<u32>> {
+    anyhow::ensure!(
+        bytes.len() <= 1024 * 1024 && bytes.ends_with(b"\n"),
+        "监听进程快照截断或过大"
+    );
+    let text = std::str::from_utf8(bytes)?;
+    let mut ids = Vec::new();
+    for line in text.lines() {
+        let pid = line.parse::<u32>()?;
+        anyhow::ensure!(pid != 0 && ids.len() < 32768, "监听进程快照无效");
+        ids.push(pid);
+    }
+    ids.sort_unstable();
+    ids.dedup();
+    anyhow::ensure!(!ids.is_empty(), "占用端口的进程归属尚未确认");
+    Ok(ids)
+}
+
+#[cfg(any(windows, target_os = "macos", test))]
+fn loopback_ports_are_free_with<T>(
+    debug_port: u16,
+    helper_port: u16,
+    mut bind: impl FnMut(&str, u16) -> std::io::Result<T>,
+    mut owners_are_unrelated: impl FnMut(u16) -> anyhow::Result<bool>,
+) -> anyhow::Result<bool> {
+    anyhow::ensure!(
+        debug_port != 0 && helper_port != 0 && debug_port != helper_port,
+        "实例端口无效"
+    );
+    let mut reservations = Vec::new();
+    for port in [debug_port, helper_port] {
+        let mut occupied = false;
+        for host in ["127.0.0.1", "::1"] {
+            match bind(host, port) {
+                Ok(listener) => reservations.push(listener),
+                Err(error)
+                    if host == "::1"
+                        && (error.kind() == std::io::ErrorKind::AddrNotAvailable
+                            || matches!(error.raw_os_error(), Some(47 | 49 | 10047 | 10049))) => {}
+                Err(error) if error.kind() == std::io::ErrorKind::AddrInUse => occupied = true,
+                Err(error) => return Err(error.into()),
+            }
+        }
+        if occupied && !owners_are_unrelated(port)? {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+
+#[cfg(any(windows, target_os = "macos", test))]
+fn arguments_user_data_matches(arguments: &[String], expected: &Path) -> anyhow::Result<bool> {
+    let mut paths = Vec::new();
+    let mut tokens = arguments.iter().skip(1);
+    while let Some(token) = tokens.next() {
+        if token == "--user-data-dir" {
+            paths.push(
+                tokens
+                    .next()
+                    .ok_or_else(|| anyhow::anyhow!("数据目录参数缺少值"))?
+                    .as_str(),
+            );
+        } else if let Some(value) = token.strip_prefix("--user-data-dir=") {
+            paths.push(value);
+        }
+    }
+    anyhow::ensure!(paths.len() <= 1, "数据目录参数重复，无法确认归属");
+    let Some(path) = paths.first() else {
+        return Ok(false);
+    };
+    anyhow::ensure!(!path.is_empty(), "数据目录参数为空");
+    let actual = Path::new(path).canonicalize()?;
+    #[cfg(windows)]
+    return Ok(actual
+        .to_string_lossy()
+        .eq_ignore_ascii_case(&expected.to_string_lossy()));
+    #[cfg(not(windows))]
+    Ok(actual == expected)
+}
+
 #[cfg(any(windows, test))]
 pub(crate) fn worker_image_matches(image: &Path, arguments: &[String]) -> bool {
     let Some(argv_image) = arguments.first().map(Path::new) else {
@@ -586,7 +1018,11 @@ pub fn worker_birth_id(child: &std::process::Child) -> Option<u64> {
     {
         crate::windows_integration::child_process_birth_id(child)
     }
-    #[cfg(not(windows))]
+    #[cfg(target_os = "macos")]
+    {
+        unix_birth_token(child.id())
+    }
+    #[cfg(not(any(windows, target_os = "macos")))]
     {
         let _ = child;
         None
@@ -606,6 +1042,331 @@ pub fn terminate_verified_worker(
 mod tests {
     use super::*;
 
+    #[cfg(windows)]
+    #[test]
+    fn absence_image_fallback_only_accepts_missing_or_denied_absolute_images() {
+        use std::io::{Error, ErrorKind};
+        let image = Path::new(r"C:\Program Files\WindowsApps\Codex\ChatGPT.exe");
+        let equivalent = Path::new(r"\\?\C:\PROGRAM FILES\WINDOWSAPPS\CODEX\CHATGPT.EXE");
+        let neighbor = Path::new(r"C:\Program Files\OtherApps\Codex\ChatGPT.exe");
+        for kind in [ErrorKind::NotFound, ErrorKind::PermissionDenied] {
+            assert!(scan_image_path_with(image, |_| Err(Error::from(kind))).unwrap().is_none());
+            assert!(scan_images_match_with(image, equivalent, |_| Err(Error::from(kind))).unwrap());
+            assert!(!scan_images_match_with(image, neighbor, |_| Err(Error::from(kind))).unwrap());
+            assert!(scan_images_match_with(Path::new("ChatGPT.exe"), image, |_| {
+                Err(Error::from(kind))
+            }).is_err());
+        }
+        for kind in [ErrorKind::Other, ErrorKind::InvalidData, ErrorKind::TimedOut] {
+            assert!(scan_images_match_with(image, image, |_| Err(Error::from(kind))).is_err());
+            assert!(scan_images_match_with(image, neighbor, |path| {
+                Err(Error::from(if path == image { ErrorKind::PermissionDenied } else { kind }))
+            }).is_err());
+        }
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn absence_image_comparison_prefers_resolved_paths_and_preserves_original_fallback() {
+        use std::io::{Error, ErrorKind};
+        let temp = tempfile::tempdir().unwrap();
+        let image = temp.path().join("ChatGPT.exe");
+        let neighbor = temp.path().join("Neighbor.exe");
+        let mut calls = 0;
+        assert!(!scan_images_match_with(&image, &image, |_| {
+            calls += 1;
+            Ok(if calls == 1 { image.clone() } else { neighbor.clone() })
+        }).unwrap());
+        assert!(scan_images_match_with(&image, &image, |path| {
+            if path == image && calls == 2 {
+                calls += 1;
+                Ok(PathBuf::from(format!(r"\\?\{}", path.display())))
+            } else {
+                Err(Error::from(ErrorKind::PermissionDenied))
+            }
+        }).unwrap());
+        std::fs::create_dir(temp.path().join("nested")).unwrap();
+        std::fs::write(&image, "").unwrap();
+        let alias = temp.path().join("nested/../ChatGPT.exe");
+        assert!(scan_images_match_with(&image, &alias, |path| path.canonicalize()).unwrap());
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn absence_image_missing_installation_does_not_block_native_neighbor_ports() {
+        let temp = tempfile::tempdir().unwrap();
+        let removed_image = temp.path().join("removed-installation/absence-image-fixture.exe");
+        let user_data = temp.path().join("own-data");
+        std::fs::create_dir(&user_data).unwrap();
+        let debug = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let helper = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let debug_port = debug.local_addr().unwrap().port();
+        let helper_port = helper.local_addr().unwrap().port();
+        assert!(codex_user_data_is_absent(&removed_image, &user_data, debug_port, helper_port).unwrap());
+        assert!(codex_user_data_is_absent(
+            &removed_image, &temp.path().join("missing-user-data"), debug_port, helper_port
+        ).is_err());
+        assert!(debug.local_addr().is_ok() && helper.local_addr().is_ok());
+    }
+
+    #[test]
+    fn macos_snapshot_preserves_spaced_images_and_rejects_incomplete_output() {
+        let snapshot = parse_macos_process_snapshot(b" 42 /Applications/Codex Dev.app/Contents/MacOS/Codex Dev\n 43 /Applications/Codex Dev.app/Contents/Frameworks/Helper (Renderer)\n").unwrap();
+        let executable = Path::new("/Applications/Codex Dev.app/Contents/MacOS/Codex Dev");
+        assert_eq!(snapshot.get(&42).unwrap(), executable);
+        assert!(macos_image_is_candidate(
+            snapshot.get(&43).unwrap(),
+            executable
+        ));
+        for invalid in [
+            &b""[..],
+            &b"\n"[..],
+            &b"42"[..],
+            &b"42 image"[..],
+            &b"42 \n"[..],
+            &b"42 image\n42 other\n"[..],
+            &b"not-pid image\n"[..],
+        ] {
+            assert!(parse_macos_process_snapshot(invalid).is_err());
+        }
+        assert!(parse_macos_process_snapshot(&vec![b'x'; 8 * 1024 * 1024 + 1]).is_err());
+        assert!(parse_macos_process_snapshot("42 image\n".repeat(32769).as_bytes()).is_err());
+        assert_eq!(
+            parse_macos_listener_process_ids(b"42\n43\n42\n").unwrap(),
+            vec![42, 43]
+        );
+        for invalid in [
+            &b""[..],
+            &b"42"[..],
+            &b"0\n"[..],
+            &b"x42\n"[..],
+            &b"42\nbad\n"[..],
+        ] {
+            assert!(parse_macos_listener_process_ids(invalid).is_err());
+        }
+    }
+
+    #[test]
+    fn macos_snapshot_refreshes_once_for_many_failed_reads_and_never_assumes_exit() {
+        use std::cell::Cell;
+        let temp = tempfile::tempdir().unwrap();
+        let own = temp.path().join("own data");
+        let neighbor = temp.path().join("neighbor data");
+        std::fs::create_dir(&own).unwrap();
+        std::fs::create_dir(&neighbor).unwrap();
+        let own = own.canonicalize().unwrap();
+        let executable = Path::new("/Applications/Codex Dev.app/Contents/MacOS/Codex Dev");
+        let snapshot = parse_macos_process_snapshot(
+            (1..=100)
+                .map(|pid| {
+                    format!(
+                        "{pid} /Applications/Codex Dev.app/Contents/Frameworks/Helper (Renderer)\n"
+                    )
+                })
+                .collect::<String>()
+                .as_bytes(),
+        )
+        .unwrap();
+        let reads = Cell::new(0);
+        assert!(
+            macos_snapshot_user_data_is_absent_with(
+                &snapshot,
+                executable,
+                &own,
+                |_| {
+                    reads.set(reads.get() + 1);
+                    Ok(vec![
+                        "Helper".into(),
+                        format!("--user-data-dir={}", neighbor.display()),
+                    ])
+                },
+                || panic!("successful reads do not spawn another ps")
+            )
+            .unwrap()
+        );
+        assert_eq!(reads.get(), 100);
+        assert!(
+            !macos_snapshot_user_data_is_absent_with(
+                &snapshot,
+                executable,
+                &own,
+                |_| {
+                    Ok(vec![
+                        "Helper".into(),
+                        format!("--user-data-dir={}", own.display()),
+                    ])
+                },
+                || panic!("live own process")
+            )
+            .unwrap()
+        );
+        for gone in [false, true] {
+            let refreshes = Cell::new(0);
+            let result = macos_snapshot_user_data_is_absent_with(
+                &snapshot,
+                executable,
+                &own,
+                |_| anyhow::bail!("process arguments unreadable"),
+                || {
+                    refreshes.set(refreshes.get() + 1);
+                    if gone {
+                        Ok(Default::default())
+                    } else {
+                        Ok(snapshot.clone())
+                    }
+                },
+            );
+            assert_eq!(refreshes.get(), 1);
+            if gone {
+                assert!(result.unwrap());
+            } else {
+                assert!(result.is_err());
+            }
+        }
+        assert!(
+            macos_snapshot_user_data_is_absent_with(
+                &snapshot,
+                executable,
+                &own,
+                |_| { anyhow::bail!("unreadable") },
+                || anyhow::bail!("snapshot failed")
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn generation_queries_keep_permission_failures_uncertain_and_compare_current_pid() {
+        let pid = std::process::id();
+        assert!(!process_generation_exited_with(pid, Some(41), |_| Ok(Some((41, false)))).unwrap());
+        assert!(process_generation_exited_with(pid, Some(40), |_| Ok(Some((41, false)))).unwrap());
+        assert!(process_generation_exited_with(pid, Some(41), |_| Ok(None)).unwrap());
+        assert!(process_generation_exited_with(pid, Some(41), |_| Ok(Some((41, true)))).unwrap());
+        assert!(!process_generation_exited_with(pid, None, |_| Ok(Some((41, false)))).unwrap());
+        assert!(
+            process_generation_exited_with(pid, Some(41), |_| {
+                Err(std::io::Error::from(std::io::ErrorKind::PermissionDenied).into())
+            })
+            .is_err()
+        );
+        assert!(process_generation_exited_with(pid, Some(41), |_| Ok(Some((0, false)))).is_err());
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn limited_query_checks_current_process_birth_without_vm_read() {
+        let pid = std::process::id();
+        let birth = crate::windows_integration::process_birth_id(pid).unwrap();
+        assert!(!codex_process_generation_exited(pid, Some(birth)).unwrap());
+        assert!(codex_process_generation_exited(pid, Some(birth + 1)).unwrap());
+        assert!(codex_process_generation_exited(u32::MAX, Some(birth)).unwrap());
+        assert!(!codex_process_generation_exited(0, Some(birth)).unwrap());
+    }
+
+    #[test]
+    fn failed_process_reads_require_independent_exit_confirmation() {
+        for stage in ["capture", "image", "arguments"] {
+            let read = || Err::<(), _>(anyhow::anyhow!("{stage} failed"));
+            assert!(
+                process_read_or_exited(read(), || Ok(true))
+                    .unwrap()
+                    .is_none()
+            );
+            assert!(process_read_or_exited(read(), || Ok(false)).is_err());
+            assert!(process_read_or_exited(read(), || anyhow::bail!("unknown")).is_err());
+            assert_eq!(
+                process_read_or_exited(Ok(41), || panic!("successful read")).unwrap(),
+                Some(41)
+            );
+        }
+    }
+
+    #[test]
+    fn absence_ports_tolerate_only_unavailable_ipv6_and_verified_neighbors() {
+        use std::io::{Error, ErrorKind};
+        for code in [47, 49, 10047, 10049] {
+            assert!(
+                loopback_ports_are_free_with(
+                    9341,
+                    9342,
+                    |host, _| {
+                        if host == "::1" {
+                            Err(Error::from_raw_os_error(code))
+                        } else {
+                            Ok(())
+                        }
+                    },
+                    |_| panic!("no occupied ports")
+                )
+                .unwrap()
+            );
+        }
+        for unrelated in [false, true] {
+            assert_eq!(
+                loopback_ports_are_free_with(
+                    9341,
+                    9342,
+                    |_, _| { Err::<(), _>(Error::from(ErrorKind::AddrInUse)) },
+                    |_| Ok(unrelated)
+                )
+                .unwrap(),
+                unrelated
+            );
+        }
+        assert!(
+            loopback_ports_are_free_with(
+                9341,
+                9342,
+                |_, _| { Err::<(), _>(Error::from(ErrorKind::PermissionDenied)) },
+                |_| Ok(true)
+            )
+            .is_err()
+        );
+        assert!(
+            loopback_ports_are_free_with(
+                9341,
+                9342,
+                |_, _| { Err::<(), _>(Error::from(ErrorKind::AddrInUse)) },
+                |_| Err(Error::from(ErrorKind::PermissionDenied).into())
+            )
+            .is_err()
+        );
+        assert!(loopback_ports_are_free_with(0, 9342, |_, _| Ok(()), |_| Ok(true)).is_err());
+    }
+
+    #[test]
+    fn lifecycle_lock_serializes_generation_and_receipt_writers() {
+        let temp = tempfile::tempdir().unwrap();
+        let first = lock_instance_lifecycle(temp.path()).unwrap();
+        let second = std::fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(temp.path().join("lifecycle.lock"))
+            .unwrap();
+        assert!(fs2::FileExt::try_lock_exclusive(&second).is_err());
+        drop(first);
+        fs2::FileExt::try_lock_exclusive(&second).unwrap();
+    }
+
+    #[test]
+    fn lifecycle_user_data_scan_requires_one_exact_directory() {
+        let temp = tempfile::tempdir().unwrap();
+        let own = temp.path().join("own data");
+        let neighbor = temp.path().join("own data other");
+        std::fs::create_dir(&own).unwrap();
+        std::fs::create_dir(&neighbor).unwrap();
+        let expected = own.canonicalize().unwrap();
+        let mut args = vec!["Codex".into(), format!("--user-data-dir={}", own.display())];
+        assert!(arguments_user_data_matches(&args, &expected).unwrap());
+        assert!(!arguments_user_data_matches(&args, &neighbor.canonicalize().unwrap()).unwrap());
+        args.push(format!("--user-data-dir={}", own.display()));
+        assert!(arguments_user_data_matches(&args, &expected).is_err());
+        assert!(
+            arguments_user_data_matches(&["Codex".into(), "--user-data-dir".into()], &expected)
+                .is_err()
+        );
+    }
+
     #[cfg(target_os = "macos")]
     #[test]
     fn macos_raw_process_arguments_match_own_test_process_argv() {
diff --git a/crates/codex-plus-core/src/multi_worker/windows_process_tree.rs b/crates/codex-plus-core/src/multi_worker/windows_process_tree.rs
index ae3bcb900..9afbb0929 100644
--- a/crates/codex-plus-core/src/multi_worker/windows_process_tree.rs
+++ b/crates/codex-plus-core/src/multi_worker/windows_process_tree.rs
@@ -13,7 +13,7 @@ enum Role {
     AppServer,
 }
 
-fn same_resolved_path(actual: &Path, expected: &Path) -> bool {
+pub(super) fn same_resolved_path(actual: &Path, expected: &Path) -> bool {
     let normalize = |path: &Path| {
         path.to_string_lossy()
             .trim_start_matches(r"\\?\")
diff --git a/crates/codex-plus-core/src/multi_worker/windows_process_tree_tests.rs b/crates/codex-plus-core/src/multi_worker/windows_process_tree_tests.rs
index 478ee2302..3f2f0f9db 100644
--- a/crates/codex-plus-core/src/multi_worker/windows_process_tree_tests.rs
+++ b/crates/codex-plus-core/src/multi_worker/windows_process_tree_tests.rs
@@ -201,7 +201,7 @@ fn spawn_fixture(dir: &Path, mode: &str, port: u16) -> Child {
         .stdin(Stdio::null());
     capture_logs(&mut command, dir, mode);
     match mode {
-        "root" => {
+        "root" | "replacement" => {
             command.arg(format!("--remote-debugging-port={port}"));
             command.arg(format!(
                 "--user-data-dir={}",
@@ -552,3 +552,68 @@ async fn already_exited_root_is_a_successful_stop_without_adopting_other_process
     assert!(terminate_verified_codex_instance(&identity).await.unwrap());
     assert!(neighbor.is_alive().unwrap());
 }
+
+#[tokio::test]
+async fn stopped_receipt_scope_preserves_neighbor_ports_but_rejects_same_data_replacement() {
+    let _fixture_lock = FIXTURE_LOCK.lock().await;
+    use crate::multi_worker::{codex_process_generation_exited, codex_user_data_is_absent};
+    let port = unused_port();
+    let fixtures = FixtureGroup::start(port);
+    let mut identity = fixtures.identity(port);
+    identity.helper_port = loop {
+        let candidate = unused_port();
+        if candidate != port {
+            break candidate;
+        }
+    };
+    let absent = || {
+        codex_user_data_is_absent(
+            &identity.executable,
+            &identity.user_data_dir,
+            identity.debug_port,
+            identity.helper_port,
+        )
+        .unwrap()
+    };
+    assert!(!absent());
+    assert!(
+        !codex_process_generation_exited(identity.process_id, Some(identity.process_birth_id))
+            .unwrap()
+    );
+    assert!(!codex_process_generation_exited(identity.process_id, None).unwrap());
+    assert!(
+        codex_process_generation_exited(identity.process_id, Some(identity.process_birth_id + 1))
+            .unwrap()
+    );
+    let mut tree = CodexInstanceProcessTree::capture(&identity).unwrap().unwrap();
+    tree.stop_and_wait().unwrap();
+    assert!(
+        codex_process_generation_exited(identity.process_id, Some(identity.process_birth_id))
+            .unwrap()
+    );
+    assert!(fixtures.process("neighbor").is_alive().unwrap());
+    assert!(fixtures.process("independent").is_alive().unwrap());
+    assert!(absent());
+    let debug = std::net::TcpListener::bind(("127.0.0.1", identity.debug_port)).unwrap();
+    assert!(absent());
+    drop(debug);
+    let helper = std::net::TcpListener::bind(("::1", identity.helper_port)).unwrap();
+    assert!(absent());
+    drop(helper);
+    assert!(absent());
+    struct Replacement(std::process::Child);
+    impl Drop for Replacement {
+        fn drop(&mut self) {
+            let _ = self.0.kill();
+            let _ = self.0.wait();
+        }
+    }
+    let replacement = Replacement(spawn_fixture(fixtures.dir.path(), "replacement", port));
+    wait_for_fixtures(
+        fixtures.dir.path(),
+        &["replacement"],
+        Duration::from_secs(10),
+    );
+    assert!(!absent());
+    drop(replacement);
+}
diff --git a/crates/codex-plus-core/src/windows_integration.rs b/crates/codex-plus-core/src/windows_integration.rs
index ee8a8ee8e..46bf82d7c 100644
--- a/crates/codex-plus-core/src/windows_integration.rs
+++ b/crates/codex-plus-core/src/windows_integration.rs
@@ -29,7 +29,8 @@ use windows::Win32::System::Registry::{
 };
 #[cfg(windows)]
 use windows::Win32::System::Threading::{
-    GetProcessTimes, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_SYNCHRONIZE,
+    GetExitCodeProcess, GetProcessTimes, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
+    PROCESS_SYNCHRONIZE,
     PROCESS_TERMINATE, PROCESS_VM_READ, QueryFullProcessImageNameW, TerminateProcess,
     WaitForSingleObject,
 };
@@ -413,6 +414,46 @@ pub fn process_birth_id(process_id: u32) -> Option<u64> {
     process_birth_id_from_handle(handle)
 }
 
+#[cfg(windows)]
+pub(crate) fn process_lifetime(process_id: u32) -> anyhow::Result<Option<(u64, bool)>> {
+    process_lifetime_with(process_id, |access, pid| unsafe {
+        OpenProcess(access, false, pid)
+    })
+}
+
+#[cfg(windows)]
+fn process_lifetime_with(
+    process_id: u32,
+    open: impl FnOnce(
+        windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS,
+        u32,
+    ) -> windows::core::Result<HANDLE>,
+) -> anyhow::Result<Option<(u64, bool)>> {
+    let handle = match open(PROCESS_QUERY_LIMITED_INFORMATION, process_id) {
+        Ok(handle) => handle,
+        Err(error) if error.code().0 as u32 == 0x80070057 => return Ok(None),
+        Err(error) => {
+            return Err(std::io::Error::from_raw_os_error(error.code().0 & 0xffff))
+                .context("无法查询进程创建身份");
+        }
+    };
+    let _guard = HandleGuard(handle);
+    let mut creation = FILETIME::default();
+    let mut exit = FILETIME::default();
+    let mut kernel = FILETIME::default();
+    let mut user = FILETIME::default();
+    unsafe { GetProcessTimes(handle, &mut creation, &mut exit, &mut kernel, &mut user) }
+        .map_err(|error| std::io::Error::from_raw_os_error(error.code().0 & 0xffff))
+        .context("无法读取进程创建身份")?;
+    let birth = ((creation.dwHighDateTime as u64) << 32) | creation.dwLowDateTime as u64;
+    anyhow::ensure!(birth != 0, "进程创建身份无效");
+    let mut exit_code = 0_u32;
+    unsafe { GetExitCodeProcess(handle, &mut exit_code) }
+        .map_err(|error| std::io::Error::from_raw_os_error(error.code().0 & 0xffff))
+        .context("无法确认进程退出状态")?;
+    Ok(Some((birth, exit_code != 259)))
+}
+
 #[cfg(windows)]
 fn process_birth_id_from_handle(handle: HANDLE) -> Option<u64> {
     let mut creation_time = FILETIME::default();
@@ -594,7 +635,7 @@ impl VerifiedStopProcess {
     pub fn capture(process_id: u32, terminate: bool) -> anyhow::Result<Option<Self>> {
         use std::os::windows::io::FromRawHandle;
         anyhow::ensure!(
-            process_id != 0 && process_id != std::process::id(),
+            process_id != 0 && (!terminate || process_id != std::process::id()),
             "拒绝捕获无效进程或当前 worker"
         );
         let rights = PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_SYNCHRONIZE | PROCESS_VM_READ;
@@ -1035,22 +1076,21 @@ fn tcp_listener_table(family: u32) -> anyhow::Result<Vec<u8>> {
 #[cfg(windows)]
 pub(crate) fn loopback_listener_process_ids(port: u16) -> anyhow::Result<Vec<u32>> {
     let mut ids = Vec::new();
-    let mut errors = Vec::new();
     for (family, ipv6) in [(2, false), (23, true)] {
         match tcp_listener_table(family)
             .and_then(|bytes| parse_listener_process_ids(&bytes, ipv6, port))
         {
             Ok(found) => ids.extend(found),
-            Err(error) => errors.push(format!("{error:#}")),
+            Err(error)
+                if ipv6
+                    && error.downcast_ref::<std::io::Error>().is_some_and(|error| {
+                        matches!(error.raw_os_error(), Some(50 | 10047 | 10049))
+                    }) => {}
+            Err(error) => return Err(error),
         }
     }
     ids.sort_unstable();
     ids.dedup();
-    anyhow::ensure!(
-        !ids.is_empty() || errors.is_empty(),
-        "{}",
-        errors.join("; ")
-    );
     Ok(ids)
 }
 
@@ -1127,6 +1167,37 @@ fn parse_listener_process_ids(bytes: &[u8], ipv6: bool, port: u16) -> anyhow::Re
 mod listener_owner_tests {
     use super::*;
 
+    #[cfg(windows)]
+    #[test]
+    fn minimum_query_survives_vm_read_denial_but_keeps_query_denial_uncertain() {
+        use windows::core::{Error, HRESULT};
+        let denied = || Error::from_hresult(HRESULT(0x80070005_u32 as i32));
+        let open = |access: windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS, pid| {
+            if access.0 & PROCESS_VM_READ.0 != 0 {
+                return Err(denied());
+            }
+            assert_eq!(access, PROCESS_QUERY_LIMITED_INFORMATION);
+            unsafe { OpenProcess(access, false, pid) }
+        };
+        let pid = std::process::id();
+        assert!(open(PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_READ, pid).is_err());
+        let (birth, exited) = process_lifetime_with(pid, open).unwrap().unwrap();
+        assert_eq!(Some(birth), process_birth_id(pid));
+        assert!(!exited);
+        let result = process_lifetime_with(pid, |access, _| {
+            assert_eq!(access, PROCESS_QUERY_LIMITED_INFORMATION);
+            Err(denied())
+        });
+        assert_eq!(
+            result
+                .unwrap_err()
+                .downcast_ref::<std::io::Error>()
+                .unwrap()
+                .kind(),
+            std::io::ErrorKind::PermissionDenied
+        );
+    }
+
     fn table(ipv6: bool, rows: &[(u32, u16, bool, u32)]) -> Vec<u8> {
         let mut bytes = (rows.len() as u32).to_ne_bytes().to_vec();
         for &(pid, port, local, state) in rows {