fix(plan): resolve runner getEnv from spawn env context

Motivation:
Runner-served getEnv values need to match the command context that planning used, including prefix envs from the command itself and enclosing nested vp run expansions. Reading only the filtered child env loses undeclared outer-prefix values.

Scope:
Add SpawnCommand::full_envs as an execution-only field, thread the planning env context into each spawn, and serve getEnv from that full context. This PR does not add cache fingerprinting for getEnv reads.

Verification:
- UPDATE_SNAPSHOTS=1 cargo test -p vite_task_bin --test e2e_snapshots fetch_env_sees_command_prefix_env -- --ignored
- UPDATE_SNAPSHOTS=1 cargo test -p vite_task_bin --test e2e_snapshots fetch_env_sees_intermediate_prefix_envs -- --ignored
- cargo test -p vite_task_bin --test e2e_snapshots fetch_env_sees_command_prefix_env -- --ignored
- cargo test -p vite_task_bin --test e2e_snapshots fetch_env_sees_intermediate_prefix_envs -- --ignored
- cargo test -p vite_task_plan plan_spawn_execution

Author: wan9chi

crates/vite_task/src/session/execute/mod.rs

@@ -157,7 +157,7 @@ impl<'a> ExecutionMode<'a> {
         cache_metadata: Option<&'a CacheMetadata>,
         stdio_config: StdioConfig,
         globbed_inputs: BTreeMap<RelativePathBuf, u64>,
-        envs: &BTreeMap<Arc<OsStr>, Arc<OsStr>>,
+        envs: &Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
     ) -> Result<Self, ExecutionError> {
         let Some(metadata) = cache_metadata else {
             return Ok(Self::Uncached {
@@ -184,10 +184,8 @@ impl<'a> ExecutionMode<'a> {
         // Bind runner IPC for every cached task. The merged cache-control API
         // (`disableCache`) must work even when a task uses explicit inputs and
         // therefore does not need fspy auto-input inference.
-        let ipc_env_map: FxHashMap<Arc<OsStr>, Arc<OsStr>> =
-            envs.iter().map(|(name, value)| (Arc::clone(name), Arc::clone(value))).collect();
         let (ipc_envs, ServerHandle { driver, stop_accepting }) =
-            serve(Recorder::new(Arc::new(ipc_env_map))).map_err(ExecutionError::IpcServerBind)?;
+            serve(Recorder::new(Arc::clone(envs))).map_err(ExecutionError::IpcServerBind)?;
         let tracking =
             Tracking { fspy, ipc_envs: ipc_envs.collect(), ipc_server_fut: driver, stop_accepting };
 
@@ -413,7 +411,7 @@ async fn run(
         cache_metadata,
         stdio_config,
         globbed_inputs,
-        &spawn_execution.spawn_command.all_envs,
+        &spawn_execution.spawn_command.full_envs,
     )
     .map_err(Report::failed)?;
 

crates/vite_task/src/session/reporter/mod.rs

@@ -481,6 +481,7 @@ pub mod test_fixtures {
                         program_path: test_path(),
                         args: Arc::from([]),
                         all_envs: Arc::new(BTreeMap::new()),
+                        full_envs: Arc::default(),
                         cwd: test_path(),
                     },
                 })),

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/scripts/fetch_intermediate_envs.mjs

@@ -0,0 +1,9 @@
+import { getEnv } from '@voidzero-dev/vite-task-client';
+
+const servedA = getEnv('PREFIXED_A') ?? '(unset)';
+const servedB = getEnv('PREFIXED_B') ?? '(unset)';
+const ownA = process.env.PREFIXED_A ?? '(unset)';
+const ownB = process.env.PREFIXED_B ?? '(unset)';
+
+console.log(`served A=${servedA} B=${servedB}`);
+console.log(`process.env A=${ownA} B=${ownB}`);

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/scripts/fetch_prefixed_env.mjs

@@ -0,0 +1,7 @@
+import { getEnv } from '@voidzero-dev/vite-task-client';
+
+const served = getEnv('PREFIXED_ENV') ?? '(unset)';
+const own = process.env.PREFIXED_ENV ?? '(unset)';
+
+console.log(`served=${served}`);
+console.log(`process.env=${own}`);

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots.toml

@@ -69,3 +69,36 @@ steps = [
     ],
   ], comment = "runner serves PROBE_ENV from the spawned task env map" },
 ]
+
+[[e2e]]
+name = "fetch_env_sees_command_prefix_env"
+comment = """
+A command-prefixed env (`PREFIXED_ENV=from-command node ...`) is part of the
+spawn's full env context. `getEnv('PREFIXED_ENV')` must serve the same value
+the child process sees in `process.env`.
+"""
+ignore = true
+steps = [
+  { argv = [
+    "vt",
+    "run",
+    "fetch-prefixed-env",
+  ], comment = "tool asks the runner for an env the command prefix sets" },
+]
+
+[[e2e]]
+name = "fetch_env_sees_intermediate_prefix_envs"
+comment = """
+Prefix envs accumulate through nested runs: `outer-prefixed` is
+`PREFIXED_A=a vt run inner-prefixed`, and `inner-prefixed` is
+`PREFIXED_B=b node ...`. The inner tool's `getEnv` must see both, even though
+only the inner prefix reaches the child process env after cache env filtering.
+"""
+ignore = true
+steps = [
+  { argv = [
+    "vt",
+    "run",
+    "outer-prefixed",
+  ], comment = "outer prefix env reaches the inner tool via the runner" },
+]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/fetch_env_sees_command_prefix_env.md

@@ -0,0 +1,13 @@
+# fetch_env_sees_command_prefix_env
+
+A command-prefixed env (`PREFIXED_ENV=from-command node ...`) is part of the spawn's full env context. `getEnv('PREFIXED_ENV')` must serve the same value the child process sees in `process.env`.
+
+## `vt run fetch-prefixed-env`
+
+tool asks the runner for an env the command prefix sets
+
+```
+$ PREFIXED_ENV=from-command node scripts/fetch_prefixed_env.mjs
+served=from-command
+process.env=from-command
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/snapshots/fetch_env_sees_intermediate_prefix_envs.md

@@ -0,0 +1,13 @@
+# fetch_env_sees_intermediate_prefix_envs
+
+Prefix envs accumulate through nested runs: `outer-prefixed` is `PREFIXED_A=a vt run inner-prefixed`, and `inner-prefixed` is `PREFIXED_B=b node ...`. The inner tool's `getEnv` must see both, even though only the inner prefix reaches the child process env after cache env filtering.
+
+## `vt run outer-prefixed`
+
+outer prefix env reaches the inner tool via the runner
+
+```
+$ PREFIXED_B=b node scripts/fetch_intermediate_envs.mjs
+served A=a B=b
+process.env A=(unset) B=b
+```

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ipc_client_test/vite-task.json

@@ -13,6 +13,18 @@
       "command": "node scripts/fetch_env.mjs",
       "env": ["PROBE_ENV"],
       "cache": true
+    },
+    "fetch-prefixed-env": {
+      "command": "PREFIXED_ENV=from-command node scripts/fetch_prefixed_env.mjs",
+      "cache": true
+    },
+    "outer-prefixed": {
+      "command": "PREFIXED_A=a vt run inner-prefixed",
+      "cache": true
+    },
+    "inner-prefixed": {
+      "command": "PREFIXED_B=b node scripts/fetch_intermediate_envs.mjs",
+      "cache": true
     }
   }
 }

crates/vite_task_plan/src/lib.rs

@@ -50,6 +50,17 @@ pub struct SpawnCommand {
     #[serde(serialize_with = "serialize_envs")]
     pub all_envs: Arc<BTreeMap<Arc<OsStr>, Arc<OsStr>>>,
 
+    /// The command's full env context: the planning context's envs, which
+    /// accumulate prefix envs from this command and enclosing nested `vp run`
+    /// expansions on top of the session envs. Runner-aware `getEnv` resolves
+    /// against this map.
+    ///
+    /// This is not passed to the child process; that remains
+    /// [`all_envs`](Self::all_envs). It is skipped in serialized plans because
+    /// it mirrors the ambient environment and would make snapshots noisy.
+    #[serde(skip)]
+    pub full_envs: Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
+
     /// Current working directory
     pub cwd: Arc<AbsolutePath>,
 }

crates/vite_task_plan/src/plan.rs

@@ -143,11 +143,11 @@ async fn plan_task_as_execution_node(
 
                 // This command's env context: extend the planning context with
                 // the command's prefix envs (`FOO=1 tool ...`). Everything that
-                // interprets the command reads this one context — program
-                // lookup, plan-request callbacks, and nested-run planning. The
-                // per-and-item duplicate above scopes the extension to this
-                // command, matching shell semantics (`FOO=1 a && b` does not
-                // set `FOO` for `b`).
+                // interprets the command reads this one context: program
+                // lookup, plan-request callbacks, nested-run planning, and the
+                // spawned process's `full_envs`. The per-and-item duplicate
+                // above scopes the extension to this command, matching shell
+                // semantics (`FOO=1 a && b` does not set `FOO` for `b`).
                 context.add_envs(and_item.envs.iter());
 
                 let mut args = and_item.args;
@@ -677,6 +677,11 @@ fn plan_spawn_execution(
         }
     }
 
+    // The runner-side full env context is the command's env context before
+    // child-env filtering. The caller already extended it with this command's
+    // prefix envs.
+    let full_envs = Arc::clone(envs);
+
     // Add prefix envs to all envs
     all_envs.extend(prefix_envs.iter().map(|(name, value)| {
         (OsStr::new(name.as_str()).into(), OsStr::new(value.as_str()).into())
@@ -688,6 +693,7 @@ fn plan_spawn_execution(
             args: Arc::clone(&args),
             cwd,
             all_envs: Arc::new(all_envs.into_iter().collect()),
+            full_envs,
         },
         cache_metadata: resolved_cache_metadata,
     })