tensor-grep 1.76.2__tar.gz → 1.76.4__tar.gz

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensor-grep
-Version: 1.76.2
+Version: 1.76.4
 Requires-Dist: typer>=0.12,<0.26
 Requires-Dist: rich>=13.0
 Requires-Dist: mcp>=1.2.0

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/pyproject.toml

@@ -530,12 +530,14 @@ version_variables = [
 
 
 
+
+
 
 
 
 [project]
 name = "tensor-grep"
-version = "1.76.2"
+version = "1.76.4"
 description = "High-performance grep-compatible CLI with Rust, GPU, and AST/NLP routing"
 readme = { file = "rust_core/README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/Cargo.lock

@@ -1579,7 +1579,7 @@ dependencies = [
 
 [[package]]
 name = "tensor_grep_rs"
-version = "1.76.2"
+version = "1.76.4"
 dependencies = [
  "aho-corasick",
  "anyhow",

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tensor_grep_rs"
-version = "1.76.2"
+version = "1.76.4"
 edition = "2021"
 description = "Rust core engine for tensor-grep"
 license = "Apache-2.0"
@@ -438,6 +438,8 @@ path = "src/bin/tg_search_fast.rs"
 
 
 
+
+
 
 
 

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/src/gpu_native.rs

@@ -361,6 +361,16 @@ pub struct GpuNativeSearchConfig {
     pub hidden: bool,
     pub max_depth: Option<usize>,
     pub max_batch_bytes: Option<usize>,
+    /// Whether the caller omitted an explicit PATH (the search root defaulted to `.` rather than
+    /// a user-supplied path). Gates `check_gpu_native_implicit_walk_ceiling`, this engine's own
+    /// refuse-before-enumerate guard (audit #109 -- the cuda-native-GPU sibling of
+    /// `NativeSearchConfig::path_was_implicit`, audit #105, itself the native-CPU sibling of
+    /// `RipgrepSearchArgs::path_was_implicit`, audit #100). An explicit, deliberately-scoped PATH
+    /// must never be refused regardless of its size. `Default`'s `false` is NOT a safe fallback for
+    /// the walk guard itself (it means "never refuse"); it only exists so ad hoc test fixtures and
+    /// the always-explicit-`--path` diagnostic commands (`gpu-native-stats`, cuda-graph benchmark)
+    /// get deterministic, non-refusing behavior, mirroring `NativeSearchConfig`'s convention.
+    pub path_was_implicit: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
@@ -3784,6 +3794,47 @@ fn ensure_capacity(capacity: usize, required: usize, path: &Path) -> Result<()>
     ))
 }
 
+/// Bounded refuse-before-enumerate gate for the GPU-native engine's own root walk -- the
+/// cuda-native sibling of `native_search::check_native_implicit_walk_ceiling` (audit #105) and
+/// `rg_passthrough::check_implicit_walk_ceiling` (audit #100). Audit #109 found the GPU-native
+/// engine had NO ceiling at all: `GpuSearchParams::path_was_implicit` (main.rs) was threaded into
+/// the CPU-fallback `RipgrepSearchArgs`/`NativeSearchConfig` redirects (`execute_gpu_native_route`'s
+/// unavailable-GPU fallback path) but never into `GpuNativeSearchConfig` itself, so a bare
+/// implicit-path `tg search PAT --gpu-device-ids 0` on a huge root walked unbounded through this
+/// engine even though the CPU engine (#105) and rg-passthrough engine (#100) were both already
+/// bounded for the exact same shape of request.
+///
+/// Only meaningful when `config.path_was_implicit` -- an explicit, deliberately-scoped PATH is
+/// never refused regardless of size. Called as the FIRST statement of `collect_walked_files`, the
+/// only function in this module that ever hands a root to `WalkBuilder`.
+fn check_gpu_native_implicit_walk_ceiling(
+    config: &GpuNativeSearchConfig,
+    roots: &[PathBuf],
+) -> Option<String> {
+    if !config.path_was_implicit {
+        return None;
+    }
+    let probe_roots: Vec<String> = roots
+        .iter()
+        .map(|root| root.to_string_lossy().into_owned())
+        .collect();
+    if crate::rg_passthrough::implicit_search_walk_exceeds_ceiling(
+        &probe_roots,
+        config.max_depth,
+        config.no_ignore,
+        config.hidden,
+        crate::rg_passthrough::IMPLICIT_SEARCH_WALK_FILE_CEILING,
+    ) {
+        Some(
+            crate::rg_passthrough::format_unbounded_implicit_search_walk_error(
+                crate::rg_passthrough::IMPLICIT_SEARCH_WALK_FILE_CEILING,
+            ),
+        )
+    } else {
+        None
+    }
+}
+
 fn collect_search_files(config: &GpuNativeSearchConfig) -> Result<Vec<PathBuf>> {
     let mut files = Vec::new();
     let mut roots = Vec::new();
@@ -3812,6 +3863,9 @@ fn collect_search_files(config: &GpuNativeSearchConfig) -> Result<Vec<PathBuf>>
 }
 
 fn collect_walked_files(config: &GpuNativeSearchConfig, roots: &[PathBuf]) -> Result<Vec<PathBuf>> {
+    if let Some(refusal) = check_gpu_native_implicit_walk_ceiling(config, roots) {
+        return Err(anyhow!(refusal));
+    }
     let builder = build_walk_builder(config, roots)?;
     let walked_files = Arc::new(std::sync::Mutex::new(Vec::new()));
     let shared_files = Arc::clone(&walked_files);
@@ -4288,13 +4342,142 @@ fn ensure_cuda_library_path() {
 #[cfg(test)]
 mod tests {
     use super::{
-        cached_search_kernel_ptx_path, kernel_compile_options_for_compute_capability,
-        line_matches_for_file, load_file_batch_into_pinned_slice, resolve_adaptive_match_capacity,
+        cached_search_kernel_ptx_path, check_gpu_native_implicit_walk_ceiling,
+        collect_search_files, kernel_compile_options_for_compute_capability, line_matches_for_file,
+        load_file_batch_into_pinned_slice, resolve_adaptive_match_capacity,
         resolve_max_match_capacity, validate_requested_cuda_device_ids, BatchedFile, FileBatchPlan,
-        LineDescriptor, PatternMatchPosition,
+        GpuNativeSearchConfig, LineDescriptor, PatternMatchPosition,
     };
     use std::fs;
-    use std::path::PathBuf;
+    use std::path::{Path, PathBuf};
+
+    // --- Audit #109: GPU-native implicit-walk-ceiling gate --------------------------------
+    // Mirrors native_search.rs's audit #105 test suite for `check_native_implicit_walk_ceiling`.
+    // #105 hoisted a walk-ceiling gate into the native-CPU engine but left the GPU-native engine
+    // (this module) with NO ceiling at all -- `GpuNativeSearchConfig` did not even have a
+    // `path_was_implicit` field, so a bare implicit-path `--gpu-device-ids` search on a huge root
+    // walked unbounded through `collect_walked_files`.
+
+    fn make_stub_file_dir(dir: &Path, file_count: usize) {
+        for index in 0..file_count {
+            fs::write(
+                dir.join(format!("stub_{index}.py")),
+                "nothing interesting\n",
+            )
+            .unwrap();
+        }
+    }
+
+    fn config_with_paths(paths: Vec<PathBuf>, path_was_implicit: bool) -> GpuNativeSearchConfig {
+        GpuNativeSearchConfig {
+            patterns: vec!["TODO".to_string()],
+            paths,
+            path_was_implicit,
+            ..GpuNativeSearchConfig::default()
+        }
+    }
+
+    #[test]
+    fn check_gpu_native_implicit_walk_ceiling_refuses_oversized_implicit_walk() {
+        // RED-before-fix: this is the exact shape of the #109 bypass -- an implicit-path search
+        // (no explicit PATH positional) on a root over the 1500-file ceiling.
+        let dir = tempfile::tempdir().unwrap();
+        make_stub_file_dir(dir.path(), 1600);
+        let roots = vec![dir.path().to_path_buf()];
+        let config = config_with_paths(roots.clone(), true);
+
+        let refusal = check_gpu_native_implicit_walk_ceiling(&config, &roots);
+
+        assert!(
+            refusal.is_some(),
+            "an oversized implicit-path walk must be refused"
+        );
+    }
+
+    #[test]
+    fn check_gpu_native_implicit_walk_ceiling_allows_explicit_path_even_when_oversized() {
+        // Non-regression (Trap #3 parity, mirrors native_search.rs/rg_passthrough.rs): an
+        // EXPLICIT, deliberately-scoped PATH must never be refused regardless of size.
+        let dir = tempfile::tempdir().unwrap();
+        make_stub_file_dir(dir.path(), 1600);
+        let roots = vec![dir.path().to_path_buf()];
+        let config = config_with_paths(roots.clone(), false);
+
+        let refusal = check_gpu_native_implicit_walk_ceiling(&config, &roots);
+
+        assert!(
+            refusal.is_none(),
+            "an explicit path must run uninhibited even when the walk exceeds the ceiling"
+        );
+    }
+
+    #[test]
+    fn check_gpu_native_implicit_walk_ceiling_allows_implicit_path_under_ceiling() {
+        // Normal-case non-regression: an implicit path under the ceiling is unaffected -- a
+        // typical repo must never be refused.
+        let dir = tempfile::tempdir().unwrap();
+        make_stub_file_dir(dir.path(), 50);
+        let roots = vec![dir.path().to_path_buf()];
+        let config = config_with_paths(roots.clone(), true);
+
+        let refusal = check_gpu_native_implicit_walk_ceiling(&config, &roots);
+
+        assert!(
+            refusal.is_none(),
+            "a 50-file implicit root must not be refused"
+        );
+    }
+
+    #[test]
+    fn collect_search_files_refuses_oversized_implicit_walk_before_enumerating() {
+        // Hermetic end-to-end test of the actual `collect_search_files` production entry point
+        // `gpu_native_search_paths_multi_with_options` calls before ever touching a CUDA device
+        // (see that function: `collect_search_files(config)?` runs BEFORE `resolve_cuda_devices`),
+        // so this test exercises the real bug with no GPU/CUDA runtime involved. Bounded per
+        // anti-hang-test-protocol: run on a joined worker thread with an explicit timeout so a
+        // regression (the gate silently stops firing) that falls through to the unbounded
+        // parallel walk cannot hang the test runner -- it fails fast with a clear panic instead.
+        let dir = tempfile::tempdir().unwrap();
+        make_stub_file_dir(dir.path(), 1600);
+        let config = config_with_paths(vec![dir.path().to_path_buf()], true);
+
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || {
+            let result = collect_search_files(&config).map_err(|error| error.to_string());
+            let _ = tx.send(result);
+        });
+        let result = rx.recv_timeout(std::time::Duration::from_secs(10)).expect(
+            "collect_search_files must return well within 10s -- a hang here means the \
+             walk-ceiling gate did not fire before an unbounded parallel walk",
+        );
+
+        let err = result.expect_err("an oversized implicit-path walk must be refused, not Ok");
+        assert!(
+            crate::rg_passthrough::is_unbounded_implicit_search_walk_refusal(&err),
+            "unexpected error (expected the walk-ceiling refusal): {err}"
+        );
+    }
+
+    #[test]
+    fn collect_search_files_does_not_refuse_explicit_oversized_path() {
+        // Non-regression: an explicit PATH (even oversized) must complete normally, not be
+        // refused -- fail-open for explicit scoping is the whole point of the guard (Trap #3
+        // parity). Bounded per anti-hang-test-protocol.
+        let dir = tempfile::tempdir().unwrap();
+        make_stub_file_dir(dir.path(), 1600);
+        let config = config_with_paths(vec![dir.path().to_path_buf()], false);
+
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || {
+            let result = collect_search_files(&config).map_err(|error| error.to_string());
+            let _ = tx.send(result);
+        });
+        let result = rx
+            .recv_timeout(std::time::Duration::from_secs(20))
+            .expect("collect_search_files must return well within 20s for an explicit path");
+
+        result.expect("an explicit oversized path must not be refused");
+    }
 
     #[test]
     fn validate_requested_cuda_device_ids_preserves_selected_subset_without_expanding() {

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/src/main.rs

@@ -10663,6 +10663,10 @@ fn gpu_native_config_from_internal_args(args: &GpuNativeStatsArgs) -> GpuNativeS
         hidden: false,
         max_depth: None,
         max_batch_bytes: args.max_batch_bytes,
+        // `GpuNativeStatsArgs::path` is a required `#[arg(long)]` (no default_value) -- this
+        // diagnostic command always has an explicit, deliberately-scoped PATH, never an implicit
+        // one, so the #109 ceiling must never fire here regardless of tree size.
+        path_was_implicit: false,
     }
 }
 
@@ -10676,6 +10680,10 @@ fn gpu_native_config_from_graph_args(args: &GpuCudaGraphArgs) -> GpuNativeSearch
         hidden: false,
         max_depth: None,
         max_batch_bytes: args.max_batch_bytes,
+        // `GpuCudaGraphArgs::path` is a required `#[arg(long)]` (no default_value) -- this
+        // benchmark command always has an explicit, deliberately-scoped PATH, never an implicit
+        // one, so the #109 ceiling must never fire here regardless of tree size.
+        path_was_implicit: false,
     }
 }
 
@@ -10764,6 +10772,12 @@ fn execute_gpu_native_route(
         hidden: params.hidden,
         max_depth: params.max_depth,
         max_batch_bytes: None,
+        // Audit #109 fix: this field did not exist on `GpuNativeSearchConfig` at all, so the
+        // GPU-native engine had no equivalent of the #105 native-CPU implicit-walk ceiling --
+        // `params.path_was_implicit` was already threaded into the CPU-fallback redirects
+        // (`ripgrep_args_for_gpu_params`, `native_search_config_for_gpu_params`) but silently
+        // dropped here, the one construction site that feeds the actual cuda kernel walk.
+        path_was_implicit: params.path_was_implicit,
     };
 
     let stats = gpu_native_search_paths_multi(&config, device_ids)?;

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/tests/test_gpu_native_graphs.rs

@@ -46,6 +46,7 @@ fn test_gpu_native_replays_captured_cuda_graphs_without_changing_results() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(4 * 1024),
+        path_was_implicit: false,
     };
 
     let benchmark = benchmark_cuda_graph_search_paths(&config, device_id).unwrap();
@@ -83,6 +84,7 @@ fn test_gpu_native_cuda_graphs_reduce_batch_overhead_by_ten_percent() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(4 * 1024),
+        path_was_implicit: false,
     };
 
     let benchmark = benchmark_cuda_graph_search_paths(&config, device_id).unwrap();

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/tests/test_gpu_native_integration.rs

@@ -777,6 +777,7 @@ fn test_gpu_native_multi_pattern_falls_back_to_batched_passes_for_large_pattern_
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(8 * 1024),
+        path_was_implicit: false,
     };
 
     let stats = gpu_native_search_paths(&config, device_id).unwrap();
@@ -821,6 +822,7 @@ fn test_gpu_native_three_pattern_dispatch_is_below_two_times_single_pattern() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: None,
+        path_was_implicit: false,
     };
     let multi_config = GpuNativeSearchConfig {
         patterns: vec![
@@ -834,6 +836,7 @@ fn test_gpu_native_three_pattern_dispatch_is_below_two_times_single_pattern() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: None,
+        path_was_implicit: false,
     };
 
     let mut single_samples = Vec::new();

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/tests/test_gpu_native_long_lines.rs

@@ -119,6 +119,7 @@ fn test_gpu_native_adaptive_dispatch_matches_cpu_for_ten_kib_lines() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(256 * 1024),
+        path_was_implicit: false,
     };
 
     let stats = gpu_native_search_paths(&config, device_id).unwrap();
@@ -161,6 +162,7 @@ fn test_gpu_native_adaptive_dispatch_matches_cpu_for_hundred_kib_lines() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(512 * 1024),
+        path_was_implicit: false,
     };
 
     let stats = gpu_native_search_paths(&config, device_id).unwrap();
@@ -202,6 +204,7 @@ fn test_gpu_native_adaptive_dispatch_classifies_mixed_short_medium_and_long_line
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(256 * 1024),
+        path_was_implicit: false,
     };
 
     let stats = gpu_native_search_paths(&config, device_id).unwrap();
@@ -263,6 +266,7 @@ fn test_gpu_native_long_line_corpus_is_not_slower_than_short_line_corpus() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(2 * 1024 * 1024),
+        path_was_implicit: false,
     };
     let long_config = GpuNativeSearchConfig {
         patterns: vec![pattern.to_string()],
@@ -272,6 +276,7 @@ fn test_gpu_native_long_line_corpus_is_not_slower_than_short_line_corpus() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(2 * 1024 * 1024),
+        path_was_implicit: false,
     };
 
     let mut short_samples = Vec::new();

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/rust_core/tests/test_gpu_native_streams.rs

@@ -80,6 +80,7 @@ fn test_gpu_native_search_reports_pinned_double_buffered_stream_pipeline() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(64 * 1024),
+        path_was_implicit: false,
     };
 
     let stats = gpu_native_search_paths(&config, device_id).unwrap();
@@ -107,6 +108,7 @@ fn test_gpu_native_overlap_matches_expected_results_without_races() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(64 * 1024),
+        path_was_implicit: false,
     };
 
     let mut actual = gpu_native_search_paths(&config, device_id)
@@ -138,6 +140,7 @@ fn test_gpu_native_overlap_metrics_show_transfer_compute_overlap() {
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(64 * 1024),
+        path_was_implicit: false,
     };
 
     let stats = gpu_native_search_paths(&config, device_id).unwrap();
@@ -189,6 +192,7 @@ fn test_gpu_native_multi_gpu_balances_distribution_and_matches_single_gpu_result
         hidden: false,
         max_depth: None,
         max_batch_bytes: Some(128 * 1024),
+        path_was_implicit: false,
     };
 
     let single = gpu_native_search_paths(&config, devices[0].device_id).unwrap();

{tensor_grep-1.76.2 → tensor_grep-1.76.4}/src/tensor_grep/cli/session_daemon.py

@@ -372,14 +372,71 @@ def _release_daemon_start_lock(root: Path) -> None:
         pass
 
 
-def _remove_daemon_metadata(root: Path) -> None:
+def _remove_daemon_metadata(
+    root: Path, *, expected_pid: int | None = None, expected_port: int | None = None
+) -> None:
+    """Remove ``daemon.json`` for ``root``, guarded against deleting a REPLACEMENT daemon's metadata.
+
+    Task #143a-a (stale-daemon-metadata race): when ``_probe_daemon`` rejects a daemon over a
+    ``package_version`` mismatch (see the skew check in ``_probe_daemon`` below), the client spawns
+    a replacement daemon (call it B) while the old daemon (A) keeps running until its own
+    idle/max-uptime self-shutdown fires. If A's shutdown path (or ``stop_session_daemon``'s
+    PID-kill fallback) unlinked ``daemon.json`` unconditionally, it would delete WHATEVER metadata
+    currently exists -- including B's, the healthy replacement -- orphaning B (it keeps serving,
+    but no client can discover it) and silently piling up orphaned daemon processes over time.
+
+    Passing ``expected_pid``/``expected_port`` re-reads the CURRENT on-disk metadata immediately
+    before unlinking and only proceeds if its ``pid``/``port`` fields still match -- i.e. the file
+    still identifies the exact instance the caller intends to remove. A mismatch (a replacement has
+    since published its own metadata), a missing file, or an unparseable/corrupt file are all
+    treated as "not mine" and left untouched -- the fail-safe choice, since we cannot prove the file
+    is safe to delete, and a corrupt file self-heals the next time a daemon is (re)started via
+    ``_spawn_daemon_subprocess``'s unconditional clear below.
+
+    When BOTH ``expected_pid`` and ``expected_port`` are omitted (the default), removal is
+    unconditional -- this mode exists for exactly one legitimate caller, ``_spawn_daemon_subprocess``,
+    which holds the daemon-start lock (excluding any concurrent spawn for this root) and is clearing
+    the slate for a brand-new instance it is about to launch, so there is no prior "self" identity to
+    compare against yet. Every other caller must supply at least one ``expected_*`` value, or skip
+    the call entirely when it cannot establish one (see ``stop_session_daemon``).
+    """
     metadata_path = _daemon_metadata_path(root)
+    if expected_pid is not None or expected_port is not None:
+        current = _read_daemon_metadata(root)
+        if current is None:
+            return
+        if expected_pid is not None and current.get("pid") != expected_pid:
+            return
+        if expected_port is not None and current.get("port") != expected_port:
+            return
     try:
         metadata_path.unlink()
     except OSError:
         pass
 
 
+def _daemon_identity(metadata: dict[str, Any] | None) -> tuple[int | None, int | None]:
+    """Best-effort ``(pid, port)`` extraction from daemon metadata (task #143a-a).
+
+    Used by callers of the guarded ``_remove_daemon_metadata`` above to compute the specific
+    instance they intend to remove. Missing or non-numeric fields resolve to ``None`` rather than
+    raising, so a malformed or partial metadata dict never turns into a removal call the guard
+    cannot safely reason about -- the caller is expected to skip the removal when either half of
+    the pair it needs comes back ``None`` (see ``stop_session_daemon``).
+    """
+    if not metadata:
+        return None, None
+    try:
+        pid: int | None = int(metadata["pid"])
+    except (KeyError, TypeError, ValueError):
+        pid = None
+    try:
+        port: int | None = int(metadata["port"])
+    except (KeyError, TypeError, ValueError):
+        port = None
+    return pid, port
+
+
 def _pid_looks_like_tg_daemon(pid: int) -> bool:
     """Best-effort check that ``pid`` is a tensor-grep session daemon (audit I7).
 
@@ -630,6 +687,12 @@ def _spawn_daemon_subprocess(root: Path) -> None:
     ``daemon.json`` to appear and does not touch the start-lock -- the caller is responsible for
     both (holding the lock across this call, and deciding whether/how long to wait afterward).
     """
+    # Task #143a-a: unconditional (force) removal is intentional and safe here -- every caller
+    # holds the daemon-start lock for `root` (excluding any concurrent spawn), so nothing else can
+    # be publishing fresh metadata for this root while we hold it, and we are about to Popen a
+    # brand-new instance that will publish its OWN metadata momentarily. There is no prior "self"
+    # identity to compare against yet, unlike the guarded callers in stop_session_daemon and
+    # run_session_daemon_server's shutdown path below.
     _remove_daemon_metadata(root)
     creationflags = 0
     env = os.environ.copy()
@@ -772,7 +835,16 @@ def stop_session_daemon(path: str = ".") -> dict[str, Any]:
         # socket is wedged). Fall back to terminating the recorded pid if it validates.
         stale_metadata = _read_daemon_metadata(root)
         killed = _terminate_daemon_by_pid(stale_metadata)
-        _remove_daemon_metadata(root)
+        # Task #143a-a: only remove the metadata that still identifies the STALE daemon we just
+        # targeted -- never whatever happens to be on disk by the time we get here. A concurrent
+        # autostart elsewhere may have already spawned and published a healthy replacement's
+        # daemon.json in the window between the failed probe above and this cleanup; an
+        # unconditional unlink would delete that replacement's metadata too. When the stale
+        # metadata itself cannot be identified (missing/corrupt), there is nothing safe to
+        # remove -- skip rather than guess.
+        stale_pid, stale_port = _daemon_identity(stale_metadata)
+        if stale_pid is not None:
+            _remove_daemon_metadata(root, expected_pid=stale_pid, expected_port=stale_port)
         return {
             "version": _SESSION_VERSION,
             "root": str(root),
@@ -802,7 +874,12 @@ def stop_session_daemon(path: str = ".") -> dict[str, Any]:
         # validated pid terminate so a wedged daemon is not left running.
         if _terminate_daemon_by_pid(metadata):
             stop_method = "pid"
-    _remove_daemon_metadata(root)
+    # Task #143a-a: only remove daemon.json if it still identifies the SAME daemon this call
+    # targeted (captured in `metadata` above) -- a replacement may have spawned and published its
+    # own metadata in the window since. See _remove_daemon_metadata's docstring for the full race.
+    target_pid, target_port = _daemon_identity(metadata)
+    if target_pid is not None:
+        _remove_daemon_metadata(root, expected_pid=target_pid, expected_port=target_port)
     response["running"] = False
     response["root"] = str(root)
     response["stopped"] = True
@@ -1965,7 +2042,13 @@ def run_session_daemon_server(path: str = ".") -> None:
         finally:
             stop_event.set()
             _flush_demand_metrics_if_dirty(server, force=True)
-            _remove_daemon_metadata(root)
+            # Task #143a-a: this daemon must only ever remove ITS OWN daemon.json on shutdown
+            # (idle timeout, max-uptime, or a cooperative "stop" command). If a client already
+            # rejected this daemon over a package_version mismatch and spawned a healthy
+            # replacement, that replacement's metadata is what is on disk by the time THIS daemon
+            # finally shuts itself down -- an unconditional unlink here would delete it out from
+            # under the replacement, orphaning it with no discoverable daemon.json.
+            _remove_daemon_metadata(root, expected_pid=os.getpid(), expected_port=int(port))
 
 
 def _parse_args(argv: list[str]) -> argparse.Namespace: