fix(fspy): replace the IPC file lock with an in-mapping close gate

The old quiescence protocol attached "may write" to the shared mapping but
"is still writing" to a file-lock descriptor. A descendant that closes
descriptors it does not recognize released the lock while keeping full
write access to the mapping, so the receiver could read frames while a
straggler was mutating them.

Put the gate in the shared memory itself, where a writer cannot drop it
while still being able to write: one atomic word admits and counts claims,
and the runner's close is a single `fetch_or` at root-process exit that
fences all future claims and reports whether any write was in flight. Zero
in flight proves every admitted claim ran to completion and the memory is
frozen; anything else means the run is conservatively not cached.

Tracking now stops when the root process exits instead of waiting for
lingering descendants, so a task that leaks a daemon no longer blocks the
read step, and post-exit accesses are treated as what they are: racy with
respect to the task's contract.

Closes #544.
Closes #396.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: wan9chi

CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+- **Changed** Automatic file-access tracking now stops the moment a task's root process exits. Accesses made by leftover descendants afterwards are no longer recorded and never delay `vp run`, and a task that still had a traced process mid-write at that instant is conservatively not cached ([#544](https://github.com/voidzero-dev/vite-task/issues/544), [#396](https://github.com/voidzero-dev/vite-task/issues/396), [#577](https://github.com/voidzero-dev/vite-task/pull/577)).
 - **Fixed** Automatic file-access tracking now backs its shared memory with a sparse temporary file on every platform, so tasks are still tracked inside coding-agent sandboxes that deny POSIX shared memory and Unix domain sockets ([#563](https://github.com/voidzero-dev/vite-task/issues/563), [#576](https://github.com/voidzero-dev/vite-task/pull/576)).
 - **Added** Tasks now run with `VP_RUN=1` set, so tools can tell they are running under `vp run` instead of being invoked directly ([#570](https://github.com/voidzero-dev/vite-task/pull/570)).
 - **Fixed** The task cache now supports much larger automatically tracked input sets without hitting wincode's default 4 MiB sequence preallocation limit ([#554](https://github.com/voidzero-dev/vite-task/pull/554)).

Cargo.lock

@@ -1,38 +1,4 @@
-use std::io;
-
-use fspy_shared::ipc::{
-    PathAccess,
-    channel::{Receiver, ReceiverLockGuard},
-};
-use tokio::task::spawn_blocking;
-
 // Shared memory size for storing path accesses.
 // 4 GiB is large enough to store path accesses in almost any realistic scenario.
 // This doesn't allocate physical memory until it's actually used.
 pub const SHM_CAPACITY: usize = 4 * 1024 * 1024 * 1024;
-
-#[ouroboros::self_referencing]
-pub struct OwnedReceiverLockGuard {
-    /// Owns the shared memory
-    receiver: Receiver,
-    /// Borrows the shared memory and owns the file lock
-    #[borrows(receiver)]
-    #[covariant]
-    lock_guard: ReceiverLockGuard<'this>,
-}
-
-impl OwnedReceiverLockGuard {
-    pub fn lock(receiver: Receiver) -> io::Result<Self> {
-        Self::try_new(receiver, fspy_shared::ipc::channel::Receiver::lock)
-    }
-
-    pub async fn lock_async(receiver: Receiver) -> io::Result<Self> {
-        spawn_blocking(move || Self::lock(receiver)).await.expect("lock task panicked")
-    }
-
-    pub fn iter_path_accesses(&self) -> impl Iterator<Item = PathAccess<'_>> {
-        self.borrow_lock_guard()
-            .iter_frames()
-            .map(|frame| wincode::deserialize_exact(frame).unwrap())
-    }
-}

crates/fspy/src/ipc.rs

@@ -10,7 +10,10 @@ use std::{io, path::Path};
 use fspy_seccomp_unotify::supervisor::supervise;
 use fspy_shared::ipc::PathAccess;
 #[cfg(not(target_env = "musl"))]
-use fspy_shared::ipc::{NativeStr, channel::channel};
+use fspy_shared::ipc::{
+    NativeStr,
+    channel::{ChannelFrames, channel},
+};
 #[cfg(target_os = "macos")]
 use fspy_shared_unix::payload::Artifacts;
 use fspy_shared_unix::{
@@ -25,7 +28,7 @@ use tokio::task::spawn_blocking;
 use tokio_util::sync::CancellationToken;
 
 #[cfg(not(target_env = "musl"))]
-use crate::ipc::{OwnedReceiverLockGuard, SHM_CAPACITY};
+use crate::ipc::SHM_CAPACITY;
 use crate::{ChildTermination, Command, TrackedChild, arena::PathAccessArena, error::SpawnError};
 
 #[derive(Debug)]
@@ -158,15 +161,24 @@ impl SpyImpl {
                 );
                 let arenas = arenas.collect::<Vec<_>>();
 
-                // Lock the ipc channel after the child has exited.
-                // We are not interested in path accesses from descendants after the main child has exited.
+                // Close the ipc channel now that the child has exited. We are not
+                // interested in path accesses from descendants after the main child
+                // has exited, and we do not wait for them either: closing is a
+                // single atomic operation that also fences out later writers.
+                // A close error means a traced process was still mid-write; its
+                // frames cannot be read safely, so the run is incomplete.
                 #[cfg(not(target_env = "musl"))]
-                let ipc_receiver_lock_guard =
-                    OwnedReceiverLockGuard::lock_async(ipc_receiver).await?;
+                let (shm_frames, incomplete) = ipc_receiver
+                    .close()
+                    .map_or_else(|_| (None, true), |frames| (Some(frames), false));
                 let path_accesses = PathAccessIterable {
                     arenas,
                     #[cfg(not(target_env = "musl"))]
-                    ipc_receiver_lock_guard,
+                    shm_frames,
+                    #[cfg(not(target_env = "musl"))]
+                    incomplete,
+                    #[cfg(target_env = "musl")]
+                    incomplete: false,
                 };
 
                 io::Result::Ok(ChildTermination { status, path_accesses })
@@ -179,8 +191,12 @@ impl SpyImpl {
 
 pub struct PathAccessIterable {
     arenas: Vec<PathAccessArena>,
+    /// `None` when the channel could not be frozen for reading.
     #[cfg(not(target_env = "musl"))]
-    ipc_receiver_lock_guard: OwnedReceiverLockGuard,
+    shm_frames: Option<ChannelFrames>,
+    /// A traced process was still writing when the channel closed, so the
+    /// recorded accesses are not a complete picture of the run.
+    incomplete: bool,
 }
 
 impl PathAccessIterable {
@@ -190,12 +206,20 @@ impl PathAccessIterable {
 
         #[cfg(not(target_env = "musl"))]
         {
-            let accesses_in_shm = self.ipc_receiver_lock_guard.iter_path_accesses();
+            let accesses_in_shm =
+                self.shm_frames.iter().flat_map(ChannelFrames::iter_path_accesses);
             accesses_in_shm.chain(accesses_in_arena)
         }
         #[cfg(target_env = "musl")]
         {
             accesses_in_arena
         }
     }
+
+    /// Whether tracking was cut short, which makes the accesses above an
+    /// incomplete record of the run.
+    #[must_use]
+    pub const fn is_incomplete(&self) -> bool {
+        self.incomplete
+    }
 }

crates/fspy/src/unix/mod.rs

@@ -8,7 +8,10 @@ use std::{
 
 use fspy_detours_sys::{DetourCopyPayloadToProcess, DetourUpdateProcessWithDll};
 use fspy_shared::{
-    ipc::{PathAccess, channel::channel},
+    ipc::{
+        PathAccess,
+        channel::{ChannelFrames, channel},
+    },
     windows::{PAYLOAD_ID, Payload},
 };
 use futures_util::FutureExt;
@@ -21,21 +24,29 @@ use winapi::{
 use winsafe::co::{CP, WC};
 
 use crate::{
-    ChildTermination, TrackedChild,
-    command::Command,
-    error::SpawnError,
-    ipc::{OwnedReceiverLockGuard, SHM_CAPACITY},
+    ChildTermination, TrackedChild, command::Command, error::SpawnError, ipc::SHM_CAPACITY,
 };
 
 const INTERPOSE_CDYLIB: Artifact = artifact!("fspy_preload");
 
 pub struct PathAccessIterable {
-    ipc_receiver_lock_guard: OwnedReceiverLockGuard,
+    /// `None` when the channel could not be frozen for reading.
+    shm_frames: Option<ChannelFrames>,
+    /// A traced process was still writing when the channel closed, so the
+    /// recorded accesses are not a complete picture of the run.
+    incomplete: bool,
 }
 
 impl PathAccessIterable {
     pub fn iter(&self) -> impl Iterator<Item = PathAccess<'_>> {
-        self.ipc_receiver_lock_guard.iter_path_accesses()
+        self.shm_frames.iter().flat_map(ChannelFrames::iter_path_accesses)
+    }
+
+    /// Whether tracking was cut short, which makes the accesses above an
+    /// incomplete record of the run.
+    #[must_use]
+    pub const fn is_incomplete(&self) -> bool {
+        self.incomplete
     }
 }
 
@@ -159,10 +170,15 @@ impl SpyImpl {
                         child.wait().await?
                     }
                 };
-                // Lock the ipc channel after the child has exited.
-                // We are not interested in path accesses from descendants after the main child has exited.
-                let ipc_receiver_lock_guard = OwnedReceiverLockGuard::lock_async(receiver).await?;
-                let path_accesses = PathAccessIterable { ipc_receiver_lock_guard };
+                // Close the ipc channel now that the child has exited. We are not
+                // interested in path accesses from descendants after the main child
+                // has exited, and we do not wait for them either: closing is a
+                // single atomic operation that also fences out later writers.
+                // A close error means a traced process was still mid-write; its
+                // frames cannot be read safely, so the run is incomplete.
+                let (shm_frames, incomplete) =
+                    receiver.close().map_or_else(|_| (None, true), |frames| (Some(frames), false));
+                let path_accesses = PathAccessIterable { shm_frames, incomplete };
 
                 io::Result::Ok(ChildTermination { status, path_accesses })
             })

crates/fspy/src/windows/mod.rs

@@ -7,7 +7,10 @@ use std::{
 };
 
 use convert::{ToAbsolutePath, ToAccessMode};
-use fspy_shared::ipc::{PathAccess, channel::Sender};
+use fspy_shared::ipc::{
+    PathAccess,
+    channel::{ClaimError, Sender},
+};
 use fspy_shared_unix::{
     exec::ExecResolveConfig,
     payload::EncodedPayload,
@@ -78,9 +81,15 @@ impl Client {
         let frame_size = NonZeroUsize::new(serialized_size)
             .expect("fspy: encoded PathAccess should never be empty");
 
-        let mut frame = ipc_sender
-            .claim_frame(frame_size)
-            .expect("fspy: failed to claim frame in shared memory");
+        let mut frame = match ipc_sender.claim_frame(frame_size) {
+            Ok(frame) => frame,
+            // The channel was closed because the traced root process exited.
+            // Accesses from whatever is left behind are dropped by design.
+            Err(ClaimError::Closed) => return Ok(()),
+            Err(ClaimError::Capacity) => {
+                panic!("fspy: failed to claim frame in shared memory")
+            }
+        };
         let mut writer: &mut [u8] = &mut frame;
         PathAccess::serialize_into(&mut writer, &path_access)?;
         assert_eq!(writer.len(), 0);

crates/fspy_preload_unix/src/client/mod.rs

@@ -2,7 +2,10 @@ use std::{cell::SyncUnsafeCell, ffi::CStr, mem::MaybeUninit};
 
 use fspy_detours_sys::DetourCopyPayloadToProcess;
 use fspy_shared::{
-    ipc::{PathAccess, channel::Sender},
+    ipc::{
+        PathAccess,
+        channel::{ClaimError, Sender, WriteEncodedError},
+    },
     windows::{PAYLOAD_ID, Payload},
 };
 use winapi::{shared::minwindef::BOOL, um::winnt::HANDLE};
@@ -40,7 +43,13 @@ impl<'a> Client<'a> {
         let Some(sender) = &self.ipc_sender else {
             return;
         };
-        sender.write_encoded(&access).expect("failed to send path access");
+        match sender.write_encoded(&access) {
+            Ok(())
+            // The channel was closed because the traced root process exited.
+            // Accesses from whatever is left behind are dropped by design.
+            | Err(WriteEncodedError::Claim(ClaimError::Closed)) => {}
+            Err(err) => panic!("failed to send path access: {err:?}"),
+        }
     }
 
     pub unsafe fn prepare_child_process(&self, child_handle: HANDLE) -> BOOL {

crates/fspy_preload_windows/src/windows/client.rs

@@ -14,8 +14,6 @@ bytemuck = { workspace = true, features = ["must_cast", "derive"] }
 fspy_shm = { workspace = true }
 native_str = { workspace = true }
 thiserror = { workspace = true }
-tracing = { workspace = true }
-uuid = { workspace = true, features = ["v4"] }
 vite_path = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
@@ -27,7 +25,6 @@ assert2 = { workspace = true }
 ctor = { workspace = true }
 rustc-hash = { workspace = true }
 subprocess_test = { workspace = true }
-tokio = { workspace = true, features = ["macros", "net", "rt-multi-thread", "time"] }
 
 [lints]
 workspace = true