@@ -1,7 +1,7 @@
 # Changelog
 
 - **Fixed** A process that inherits Vite+'s file-access tracking library without its configuration, such as in a sandbox that scrubs environment variables, no longer aborts at startup; it runs untracked instead ([#753](https://github.com/voidzero-dev/vite-task/pull/753)).
-- **Fixed** Cached tasks no longer fail to spawn child processes in restricted sandboxes (e.g. rootless bubblewrap that denies the `seccomp` syscall). When file-access tracking cannot be set up for a process, the process runs untracked instead and the run is reported as not cached ([#700](https://github.com/voidzero-dev/vite-task/issues/700), [#701](https://github.com/voidzero-dev/vite-task/pull/701)).
+- **Fixed** Cached tasks no longer fail to spawn child processes in restricted sandboxes (e.g. rootless bubblewrap that denies the `seccomp` syscall). When the `seccomp` filter for file-access tracking cannot be installed, the process runs untracked instead and the run is reported as not cached. The not-cached message now reads "automatic file tracking couldn't record everything this task did", which fits both this case and a full tracking channel ([#700](https://github.com/voidzero-dev/vite-task/issues/700), [#701](https://github.com/voidzero-dev/vite-task/pull/701)).
 - **Changed** Tasks that write a file they also read are now cached, instead of being reported as `not cached because it modified its inputs`. For example, `tsc --incremental` reads and rewrites `tsconfig.tsbuildinfo`: the next run is a cache hit if the file is as `tsc` left it, or if it is missing, as on a fresh clone, in which case the hit restores it ([#913](https://github.com/voidzero-dev/vite-task/pull/913)).
 - **Fixed** A cache hit restores the symbolic links a task's `output` globs match as links, instead of dropping them, so a replayed output that links a directory, such as a bundler's `node_modules/<package>` link, is complete ([#885](https://github.com/voidzero-dev/vite-task/pull/885)).
 - **Fixed** On Linux and macOS, programs using automatic file-access tracking no longer abort when they call `execve`, `execv`, `execl`, `execle`, or `posix_spawn` with an empty path; the call fails with `ENOENT`, as it does without tracking. On Linux, `execveat` with an empty path and without `AT_EMPTY_PATH` now also fails with `ENOENT`, instead of trying to run what its directory descriptor refers to ([#896](https://github.com/voidzero-dev/vite-task/pull/896)).
 
@@ -35,10 +35,13 @@ pub enum SpawnError {
 /// so the accesses collected for the run are a subset of what it really
 /// touched.
 ///
+/// The tracking channel can be full, or a process can continue untracked
+/// because the seccomp filter could not be installed.
+///
 /// The run itself is unaffected: recording must never stop the program
 /// doing the work. What cannot be done is anything that needs every
 /// access, caching above all, which has to treat the run as untracked
 /// rather than as having touched only the paths that fit.
 #[derive(thiserror::Error, Clone, Copy, PartialEq, Eq, Debug)]
-#[error("the file-access records did not fit in the tracking channel")]
+#[error("automatic file tracking could not record every file access")]
 pub struct TrackingIncomplete;
@@ -1,6 +1,6 @@
 //! Tests for the untracked-exec fallback: when the preload cannot install
-//! its injection machinery, the exec must proceed untracked and the run must
-//! be reported as incompletely tracked (so it is not cached), rather than
+//! the seccomp filter, the exec must proceed untracked and the run must be
+//! reported as incompletely tracked (so it is not cached), rather than
 //! every spawn failing. Skipped on musl: no preload library exists there.
 #![cfg(all(target_os = "linux", not(target_env = "musl")))]
 
@@ -115,6 +115,46 @@ fn execvp_fallback_keeps_path_search() {
     };
 }
 
+/// Only a failed seccomp install takes the untracked path. An exec that
+/// fails the way the real exec would, here `ENOEXEC` for a script without a
+/// `#!` line, keeps its errno and leaves the trace complete. `sh` then runs
+/// the script itself, as it does without tracking.
+#[test]
+fn exec_errors_are_not_reported_as_lost() {
+    let script = PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join("fspy-script-without-shebang");
+    fs::write(&script, "exit 0\n").expect("failed to write the script");
+    fs::set_permissions(&script, Permissions::from_mode(0o755))
+        .expect("failed to set permissions on the script");
+
+    let receiver = channel(1 << 30, Global).unwrap();
+    let preload_path: &IpcStr = Path::new(PRELOAD_CDYLIB).into();
+    let payload = Payload {
+        ipc_channel_conf: receiver.conf(),
+        preload_path,
+        seccomp_payload: SeccompPayload::unreachable(
+            b"/nonexistent/fspy-unreachable-supervisor".to_vec(),
+        ),
+    };
+    let bump = bumpalo::Bump::new();
+    let encoded = encode_payload(payload, &bump);
+
+    let output = Command::new("/bin/sh")
+        .arg("-c")
+        .arg(script.as_os_str())
+        .env_clear()
+        .env("LD_PRELOAD", PRELOAD_CDYLIB)
+        .env("FSPY_PAYLOAD", OsStr::from_bytes(encoded.encoded_string.as_ref()))
+        .output()
+        .expect("failed to spawn the shell");
+    assert!(
+        output.status.success(),
+        "the script without a shebang did not run: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    assert!(receiver.close().is_ok(), "an authentic exec error was reported as an untracked exec");
+}
+
 /// A preload loaded without a payload (e.g. a leaked `LD_PRELOAD` in an
 /// env-scrubbed sandbox) must not abort its host process: the constructor
 /// degrades and every exec forwards to the original.
 
@@ -16,35 +16,10 @@ use fspy_shared::ipc::{AccessMode, channel::Sender};
 use fspy_shared_unix::{
     exec::ExecResolveConfig,
     payload::{EncodedPayload, decode_payload_from_env},
-    spawn::{PreExec, prepare_exec, resolve_exec},
+    spawn::{PreExec, handle_exec},
 };
 use raw_exec::RawExec;
 
-/// Why [`Client::handle_exec`] failed.
-#[derive(Debug)]
-pub enum ExecInjectionError {
-    /// Program resolution failed the way the real exec would have; the errno
-    /// is authentic and the caller should surface it as the exec's own
-    /// failure (set errno and return -1, or return it from `posix_spawn`).
-    Resolution(nix::Error),
-    /// The tracing injection machinery failed after the program resolved;
-    /// the exec was never attempted. The caller should mark the run's trace
-    /// incomplete ([`Client::report_loss`]) and perform the operation
-    /// untracked.
-    Injection(nix::Error),
-}
-
-impl std::fmt::Display for ExecInjectionError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Resolution(errno) => write!(f, "exec resolution failed: {errno}"),
-            Self::Injection(errno) => write!(f, "exec injection failed: {errno}"),
-        }
-    }
-}
-
-impl std::error::Error for ExecInjectionError {}
-
 pub struct Client<'a> {
     encoded_payload: EncodedPayload<'a>,
     ipc_sender: Option<Sender>,
@@ -115,10 +90,10 @@ impl<'a> Client<'a> {
     }
 
     /// Marks the run's trace incomplete, so the receiver treats it as
-    /// untracked (and the runner does not cache it). Used before executing
-    /// something untracked, e.g. when the injection machinery failed and the
-    /// exec is forwarded to the OS as-is. A no-op when this client has no
-    /// channel sender.
+    /// untracked and the runner does not cache it. Call it before the
+    /// process does something that tracking cannot record, such as an exec
+    /// that continues untracked because [`PreExec::run`] failed. It does
+    /// nothing when this client has no channel sender.
     pub fn report_loss(&self) {
         if let Some(ipc_sender) = &self.ipc_sender {
             ipc_sender.report_loss();
@@ -128,11 +103,6 @@ impl<'a> Client<'a> {
     /// Resolves and reports an exec, returning the transformed arguments to
     /// forward and what to run before forwarding them.
     ///
-    /// A failure of the returned [`PreExec::run`], such as failing to install
-    /// the seccomp filter, is an injection machinery failure too: the caller
-    /// treats it like [`ExecInjectionError::Injection`], marks the trace
-    /// incomplete, and retries the operation untracked.
-    ///
     /// # Safety
     ///
     /// `raw_exec` must contain the valid C strings and pointer arrays required
@@ -141,24 +111,19 @@ impl<'a> Client<'a> {
     ///
     /// # Errors
     ///
-    /// [`ExecInjectionError::Resolution`] when program resolution fails the
-    /// way the real exec would have; [`ExecInjectionError::Injection`] when
-    /// the injection machinery fails after the program resolved.
+    /// Returns errors from exec resolution or platform preparation.
     pub unsafe fn handle_exec<A: Allocator>(
         &self,
         config: ExecResolveConfig,
         raw_exec: RawExec,
         allocator: &A,
-    ) -> Result<(RawExec, Option<PreExec>), ExecInjectionError> {
+    ) -> nix::Result<(RawExec, Option<PreExec>)> {
         // SAFETY: raw_exec contains valid pointers to C strings and
         // null-terminated arrays, as provided by the caller.
         let mut exec = unsafe { raw_exec.to_exec(allocator) };
-        resolve_exec(&mut exec, config, |path| {
+        let pre_exec = handle_exec(&mut exec, config, &self.encoded_payload, |path| {
             self.send(AccessMode::Read, path);
-        })
-        .map_err(ExecInjectionError::Resolution)?;
-        let pre_exec = prepare_exec(&mut exec, &self.encoded_payload)
-            .map_err(ExecInjectionError::Injection)?;
+        })?;
         Ok((RawExec::from_exec(exec), pre_exec))
     }
 
 
@@ -1,7 +1,7 @@
 use std::sync::OnceLock;
 
 use convert::{ToAbsolutePath, ToAccessMode};
-pub use fspy_client_unix::{Client, ExecInjectionError, convert, raw_exec};
+pub use fspy_client_unix::{Client, convert, raw_exec};
 
 static CLIENT: OnceLock<Client<'static>> = OnceLock::new();
 
 
@@ -5,7 +5,7 @@ use fspy_shared_unix::exec::ExecResolveConfig;
 use libc::{c_char, c_int};
 
 use crate::{
-    client::{ExecInjectionError, global_client, raw_exec::RawExec},
+    client::{global_client, raw_exec::RawExec},
     macros::intercept,
 };
 
@@ -55,8 +55,8 @@ unsafe fn collect_argv<A: Allocator>(
 /// `untracked` performs the interposed call as the caller made it, through
 /// that function's own original: `execvp` keeps its `PATH` search,
 /// `execveat` its `dirfd` and flags, `fexecve` its descriptor. It runs when
-/// this process has no tracking client or the injection machinery fails, so
-/// the process still execs, untracked.
+/// this process has no tracking client or the seccomp filter cannot be
+/// installed, so the process still execs, untracked.
 fn handle_exec(
     allocator: impl Allocator,
     config: ExecResolveConfig,
@@ -70,31 +70,25 @@ fn handle_exec(
         // valid payload): run untracked.
         return untracked();
     };
-    // The injection machinery failed (e.g. the seccomp filter cannot be
-    // installed under a restrictive sandbox). Mark the run's trace incomplete
-    // so it is not cached, then run the interposed call untracked. Its envp
-    // still carries LD_PRELOAD/FSPY_PAYLOAD, so each generation independently
-    // attempts tracking and independently degrades.
-    let run_untracked = || {
-        client.report_loss();
-        untracked()
-    };
     // SAFETY: prog, argv, and envp are valid pointers to C strings/arrays forwarded from the interposed exec function
     let handled = unsafe { client.handle_exec(config, RawExec { prog, argv, envp }, &allocator) };
     let (raw_command, pre_exec) = match handled {
         Ok(handled) => handled,
-        Err(ExecInjectionError::Resolution(errno)) => {
-            // Resolution failed the way the real exec would have; the errno
-            // is authentic.
+        Err(errno) => {
             errno.set();
             return -1;
         }
-        Err(ExecInjectionError::Injection(_)) => return run_untracked(),
     };
     if let Some(pre_exec) = pre_exec
         && pre_exec.run().is_err()
     {
-        return run_untracked();
+        // The seccomp filter cannot be installed, for example in a sandbox
+        // that denies the `seccomp` syscall. Mark the run's trace incomplete
+        // so it is not cached, then run the interposed call untracked. Its
+        // envp still carries LD_PRELOAD/FSPY_PAYLOAD, so each generation
+        // tries tracking again on its own.
+        client.report_loss();
+        return untracked();
     }
     // SAFETY: raw_command's strings and arrays live in `allocator`, which outlives the call
     unsafe { execve::original()(raw_command.prog, raw_command.argv, raw_command.envp) }
 
@@ -4,7 +4,7 @@ use fspy_shared_unix::exec::ExecResolveConfig;
 use libc::{c_char, c_int};
 
 use crate::{
-    client::{ExecInjectionError, global_client, raw_exec::RawExec},
+    client::{global_client, raw_exec::RawExec},
     macros::intercept,
 };
 
@@ -57,20 +57,9 @@ unsafe fn handle_posix_spawn(
             &arena,
         )
     };
-    // The injection machinery failed. Mark the run's trace incomplete so it
-    // is not cached, then spawn untracked with the original arguments.
-    let spawn_untracked = || {
-        client.report_loss();
-        // SAFETY: all arguments are the interposed posix_spawn(p) function's
-        // own valid arguments.
-        unsafe { original(pid, file, file_actions, attrp, argv, envp) }
-    };
     let (raw_command, pre_exec) = match handled {
         Ok(handled) => handled,
-        // Resolution failed the way the real spawn would have; posix_spawn
-        // returns the errno code rather than -1.
-        Err(ExecInjectionError::Resolution(errno)) => return errno as _,
-        Err(ExecInjectionError::Injection(_)) => return spawn_untracked(),
+        Err(errno) => return errno as _,
     };
     let call_original = move || {
         // SAFETY: the caller's pointers are forwarded unchanged, and raw_command's
@@ -100,8 +89,15 @@ unsafe fn handle_posix_spawn(
         .join()
         .unwrap()
     })
-    // `pre_exec.run` failed, so the spawn never happened.
-    .unwrap_or_else(|_| spawn_untracked())
+    .unwrap_or_else(|_| {
+        // The seccomp filter cannot be installed, so the spawn never
+        // happened. Mark the run's trace incomplete so it is not cached,
+        // then spawn untracked with the caller's own arguments.
+        client.report_loss();
+        // SAFETY: all arguments are the interposed posix_spawn(p) function's
+        // own valid arguments.
+        unsafe { original(pid, file, file_actions, attrp, argv, envp) }
+    })
 }
 
 intercept!(posix_spawnp(64): PosixSpawnFn);
 
@@ -62,25 +62,27 @@ pub(crate) fn absolute<A: Allocator>(path: &Path, allocator: A) -> nix::Result<V
     Ok(absolute)
 }
 
-/// Resolves the exec's program path and reports the accesses that takes.
+/// Handles exec command resolution and injection
 ///
-/// This is the half of [`handle_exec`] whose failures mean what the real
-/// exec's failure would have meant (see [`Exec::resolve`]), so a caller can
-/// forward the errno authentically.
+/// Resolves the program path and prepares the command for execution with
+/// appropriate environment variables and hooks.
 ///
 /// # Errors
 ///
-/// Returns an error if program resolution fails (see [`Exec::resolve`] error
-/// variants, such as `ENOENT` (file not found) or `EACCES` (permission denied)).
+/// Returns an error if:
+/// - Program resolution fails (see [`Exec::resolve`] error variants, such as `ENOENT` (file not found) or `EACCES` (permission denied))
+/// - Environment variable operations fail (e.g., `ensure_env` may return `EINVAL` if an existing value conflicts)
+/// - Platform-specific errors from `os_specific::handle_exec`
 ///
 /// # Panics
 ///
 /// Panics if the current working directory cannot be determined when converting a relative path to absolute.
-pub fn resolve_exec<A: Allocator + Clone>(
+pub fn handle_exec<A: Allocator + Clone>(
     command: &mut Exec<A>,
     config: ExecResolveConfig,
+    encoded_payload: &EncodedPayload,
     mut on_path_read: impl FnMut(&Path),
-) -> nix::Result<()> {
+) -> nix::Result<Option<PreExec>> {
     let allocator = command.allocator().clone();
     let mut on_path_read = |path: &Path| {
         if path.is_absolute() {
@@ -93,54 +95,10 @@ pub fn resolve_exec<A: Allocator + Clone>(
 
     command.resolve(&mut on_path_read, config)?;
     on_path_read(Path::new(OsStr::from_bytes(&command.program)));
-    Ok(())
-}
 
-/// Prepares a resolved exec for tracked execution: injects the preload
-/// environment, or arms the seccomp filter to install before exec.
-///
-/// This is the half of [`handle_exec`] whose failures are the tracing
-/// machinery's own, never the exec's.
-///
-/// # Errors
-///
-/// Returns an error if environment variable operations fail (e.g.,
-/// `ensure_env` may return `EINVAL` if an existing value conflicts) or from
-/// platform-specific errors in `os_specific::handle_exec`.
-pub fn prepare_exec<A: Allocator + Clone>(
-    command: &mut Exec<A>,
-    encoded_payload: &EncodedPayload,
-) -> nix::Result<Option<PreExec>> {
     os_specific::handle_exec(command, encoded_payload)
 }
 
-/// Handles exec command resolution and injection
-///
-/// Resolves the program path and prepares the command for execution with
-/// appropriate environment variables and hooks. Composed of [`resolve_exec`]
-/// followed by [`prepare_exec`]; call them separately to tell an authentic
-/// resolution failure apart from an injection-machinery failure.
-///
-/// # Errors
-///
-/// Returns an error if:
-/// - Program resolution fails (see [`Exec::resolve`] error variants, such as `ENOENT` (file not found) or `EACCES` (permission denied))
-/// - Environment variable operations fail (e.g., `ensure_env` may return `EINVAL` if an existing value conflicts)
-/// - Platform-specific errors from `os_specific::handle_exec`
-///
-/// # Panics
-///
-/// Panics if the current working directory cannot be determined when converting a relative path to absolute.
-pub fn handle_exec<A: Allocator + Clone>(
-    command: &mut Exec<A>,
-    config: ExecResolveConfig,
-    encoded_payload: &EncodedPayload,
-    on_path_read: impl FnMut(&Path),
-) -> nix::Result<Option<PreExec>> {
-    resolve_exec(command, config, on_path_read)?;
-    prepare_exec(command, encoded_payload)
-}
-
 #[cfg(test)]
 mod tests {
     use std::{os::unix::ffi::OsStrExt, path::Path};
 
@@ -111,11 +111,12 @@ pub enum CacheNotUpdatedReason {
     /// A runner-aware tool explicitly requested that this run not be cached
     /// (e.g. vite dev-server, a watch task).
     ToolRequested,
-    /// A tracked process could not record a file access it went on to
-    /// perform: the channel it reports them through had no room left, or
-    /// none for a record that long. The accesses that did arrive are a
-    /// subset of what the task touched, so caching from them would bake in
-    /// inputs and outputs that are not all of them.
+    /// A tracked process could not record everything it did. For example,
+    /// the channel it reports file accesses through had no room left, or
+    /// the seccomp filter could not be installed and an exec continued
+    /// untracked. The accesses that did arrive are a subset of what the
+    /// task touched, so caching from them would bake in inputs and outputs
+    /// that are not all of them.
     #[cfg_attr(not(fspy), expect(dead_code, reason = "only fspy tracking can be incomplete"))]
     TrackingIncomplete,
 }