fix(ipc): serve getEnv(s) from the spawn's full env context saved in the plan

A command-prefixed env (PREFIXED_ENV=x node tool.mjs) is part of the
spawn's env, but getEnv resolved against the session snapshot only and
answered (unset) — and recorded that wrong value into the post-run
fingerprint.

The plan now saves two env maps per spawn: all_envs (filtered, passed to
the child — unchanged) and full_envs, the planning context's envs overlaid
with the spawn's own additions. Nested expansions already thread prefix
envs into the context, so full_envs picks up enclosing runs' prefixes too
(taskA: PREFIXED_A=a vt run taskB → taskB's getEnv sees PREFIXED_A).
full_envs is serde-skipped: it mirrors the ambient env and is not part of
the plan's identity.

The Recorder and tracked-env validation both use full_envs, keeping record
and lookup symmetric per cache key (prefix envs are in the spawn
fingerprint, so a changed prefix is a different entry).

e2e: fetch_env_sees_command_prefix_env (was failing, now green) and
fetch_env_sees_intermediate_prefix_envs (nested prefix accumulation +
cache-hit validation).

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

Author: wan9chi

Cargo.lock

@@ -45,6 +45,7 @@ tracing = { workspace = true }
 twox-hash = { workspace = true }
 materialized_artifact = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
+vite_glob = { workspace = true }
 vite_path = { workspace = true }
 vite_select = { workspace = true }
 vite_str = { workspace = true }

crates/vite_task/Cargo.toml

@@ -726,7 +726,6 @@ impl<'a> Session<'a> {
             &spawn_execution,
             cache,
             &self.workspace_path,
-            &self.envs,
             &self.cache_path,
             self.program_name.as_str(),
             tokio_util::sync::CancellationToken::new(),

crates/vite_task/src/session/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::new(rustc_hash::FxHashMap::default()),
                         cwd: test_path(),
                     },
                 })),

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

@@ -0,0 +1,18 @@
+import { getEnv } from '@voidzero-dev/vite-task-client';
+import { writeFileSync, mkdirSync } from 'node:fs';
+
+// Reached via `outer-prefixed` (`PREFIXED_A=a vt run inner-prefixed`): the
+// nested run carries PREFIXED_A into the planning context, and our own
+// command (`PREFIXED_B=b node ...`) prefixes PREFIXED_B. getEnv must serve
+// both. Only PREFIXED_B reaches this process's env — PREFIXED_A is
+// undeclared, so the spawn env filters it; the runner still knows it.
+const servedA = getEnv('PREFIXED_A', { tracked: true }) ?? '(unset)';
+const servedB = getEnv('PREFIXED_B', { tracked: true }) ?? '(unset)';
+const ownA = process.env.PREFIXED_A ?? '(unset)';
+const ownB = process.env.PREFIXED_B ?? '(unset)';
+
+mkdirSync('dist', { recursive: true });
+writeFileSync(
+  'dist/out.txt',
+  `served A=${servedA} B=${servedB}\nprocess.env A=${ownA} B=${ownB}\n`,
+);

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

@@ -0,0 +1,12 @@
+import { getEnv } from '@voidzero-dev/vite-task-client';
+import { writeFileSync, mkdirSync } from 'node:fs';
+
+// The task command prefixes `PREFIXED_ENV=from-command` (see vite-task.json),
+// so this process's own env carries that value. `getEnv` must serve the same
+// value: the runner resolves from the spawn's env context (session env
+// overlaid with the command's prefix envs), not the session env alone.
+const served = getEnv('PREFIXED_ENV', { tracked: true }) ?? '(unset)';
+const own = process.env.PREFIXED_ENV ?? '(unset)';
+
+mkdirSync('dist', { recursive: true });
+writeFileSync('dist/out.txt', `served=${served}\nprocess.env=${own}\n`);

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

@@ -0,0 +1,24 @@
+# fetch_env_sees_command_prefix_env
+
+A command-prefixed env (`PREFIXED_ENV=from-command node ...`) is part of the
+spawn's env context: the child process sees it in `process.env`, so
+`getEnv('PREFIXED_ENV')` must serve the same value. Today the runner resolves
+`getEnv` against the session env snapshot only, so it answers `(unset)` while
+the process env says `from-command`.
+
+## `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
+```
+
+## `vtt print-file dist/out.txt`
+
+served value must match the process env value
+
+```
+served=from-command
+process.env=from-command
+```

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

@@ -0,0 +1,37 @@
+# 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 — the
+nested expansion threads PREFIXED_A into the inner spawn's env context even
+though the (undeclared) var never reaches the inner process env. The second
+run validates the tracked values against the same plan-derived context and
+hits the cache.
+
+## `vt run outer-prefixed`
+
+outer prefix env reaches the inner tool via the runner
+
+```
+$ PREFIXED_B=b node scripts/fetch_intermediate_envs.mjs
+```
+
+## `vtt print-file dist/out.txt`
+
+both prefix envs served; only the inner one is in process.env
+
+```
+served A=a B=b
+process.env A=(unset) B=b
+```
+
+## `vt run outer-prefixed`
+
+cache hit: tracked values validate against the plan's env context
+
+```
+$ PREFIXED_B=b node scripts/fetch_intermediate_envs.mjs ◉ cache hit, replaying
+
+---
+vt run: cache hit.
+```

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

@@ -30,10 +30,10 @@ pub struct PlanContext<'a> {
     /// The environment variables for the current execution context.
     ///
     /// `Arc`-shared with copy-on-write semantics: [`duplicate`](Self::duplicate)
-    /// and downstream consumers (`ScriptCommand::envs`) share the map;
-    /// mutations ([`add_envs`](Self::add_envs),
-    /// [`prepend_path`](Self::prepend_path)) clone only when the map is
-    /// currently shared.
+    /// and downstream consumers (`ScriptCommand::envs`,
+    /// `SpawnCommand::full_envs`) share the map; mutations
+    /// ([`add_envs`](Self::add_envs), [`prepend_path`](Self::prepend_path))
+    /// clone only when the map is currently shared.
     envs: Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
 
     /// The callbacks for loading task graphs and parsing commands.

crates/vite_task_plan/src/context.rs

@@ -50,6 +50,18 @@ 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 the prefix envs of this command and of enclosing nested
+    /// `vp run` expansions on top of the session envs. Resolves runner-aware
+    /// `getEnv`/`getEnvs` requests and validates tracked envs at cache lookup.
+    ///
+    /// Not passed to the child process — that is the filtered
+    /// [`all_envs`](Self::all_envs). Skipped in serialized plans: it mirrors the ambient
+    /// environment, which is not part of the plan's identity and would bloat
+    /// snapshots nondeterministically.
+    #[serde(skip)]
+    pub full_envs: Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
+
     /// Current working directory
     pub cwd: Arc<AbsolutePath>,
 }