feat: handle self-recursion in task planning (#197)

## Summary
- Add skip rule and prune rule to prevent infinite recursion when workspace root tasks reference themselves (e.g., `"build": "vp run -r build"`)
- Reject unknown fields in `vite-task.json` with `deny_unknown_fields`
- Test coverage for extra_arg interaction and `cd` changing the cwd

## Stack
- #196

## Test plan
- [x] Plan snapshot tests for self-reference, multi-command, mutual recursion, depends-on passthrough, cd-no-skip fixtures
- [x] Unit tests for unknown field rejection at top-level and task-level
- [x] All plan snapshot tests pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: branchseer

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "test-workspace",
+  "private": true,
+  "scripts": {
+    "build": "vp run -r build"
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/packages/a/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@test/a",
+  "version": "1.0.0",
+  "scripts": {
+    "build": "echo building-a"
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/packages/b/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@test/b",
+  "version": "1.0.0",
+  "scripts": {
+    "build": "echo building-b"
+  },
+  "dependencies": {
+    "@test/a": "workspace:*"
+  }
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - 'packages/*'

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/snapshots.toml

@@ -0,0 +1,23 @@
+# Tests that workspace root self-referencing tasks don't cause infinite recursion.
+# Root build = `vp run -r build` (delegates to all packages recursively).
+#
+# Skip rule: `vp run -r build` from root produces the same query as the
+# nested `vp run -r build` in root's script, so root's expansion is skipped.
+# Only packages a and b actually run.
+#
+# Prune rule: `vp run build` from root produces a ContainingPackage query,
+# but root's script `vp run -r build` produces an All query. The queries
+# differ so the skip rule doesn't fire. Instead the prune rule removes root
+# from the nested result, leaving only a and b.
+
+[[e2e]]
+name = "recursive build skips root self-reference"
+steps = [
+  "vp run -r build # only a and b run, root is skipped",
+]
+
+[[e2e]]
+name = "build from root prunes root from nested expansion"
+steps = [
+  "vp run build # only a and b run under root, root is pruned",
+]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/snapshots/build from root prunes root from nested expansion.snap

@@ -0,0 +1,13 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+---
+> vp run build # only a and b run under root, root is pruned
+~/packages/a$ echo building-a ⊘ cache disabled
+building-a
+
+~/packages/b$ echo building-b ⊘ cache disabled
+building-b
+
+---
+[vp run] 0/2 cache hit (0%). (Run `vp run --last-details` for full details)

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/snapshots/recursive build skips root self-reference.snap

@@ -0,0 +1,13 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+---
+> vp run -r build # only a and b run, root is skipped
+~/packages/a$ echo building-a ⊘ cache disabled
+building-a
+
+~/packages/b$ echo building-b ⊘ cache disabled
+building-b
+
+---
+[vp run] 0/2 cache hit (0%). (Run `vp run --last-details` for full details)

crates/vite_task_bin/tests/e2e_snapshots/fixtures/workspace-root-self-reference/vite-task.json

@@ -0,0 +1,3 @@
+{
+  "cache": true
+}

crates/vite_task_graph/src/config/user.rs

@@ -177,7 +177,7 @@ impl ResolvedGlobalCacheConfig {
 #[derive(Debug, Default, Deserialize)]
 // TS derive macro generates code using std types that clippy disallows; skip derive during linting
 #[cfg_attr(all(test, not(clippy)), derive(TS), ts(optional_fields, rename = "RunConfig"))]
-#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct UserRunConfig {
     /// Root-level cache configuration.
     ///
@@ -454,4 +454,17 @@ mod tests {
             serde_json::from_value::<UserGlobalCacheConfig>(json!({ "unknown": true })).is_err()
         );
     }
+
+    #[test]
+    fn test_run_config_unknown_top_level_field() {
+        assert!(serde_json::from_value::<UserRunConfig>(json!({ "unknown": true })).is_err());
+    }
+
+    #[test]
+    fn test_task_config_unknown_field() {
+        assert!(
+            serde_json::from_value::<UserTaskConfig>(json!({ "command": "echo", "unknown": true }))
+                .is_err()
+        );
+    }
 }

crates/vite_task_graph/src/query/mod.rs

@@ -31,7 +31,20 @@ use crate::{IndexedTaskGraph, TaskDependencyType, TaskId, TaskNodeIndex};
 pub type TaskExecutionGraph = DiGraphMap<TaskNodeIndex, ()>;
 
 /// A query for which tasks to run.
-#[derive(Debug)]
+///
+/// A `TaskQuery` must be **self-contained**: it fully describes which tasks
+/// will be selected, without relying on ambient state such as cwd or
+/// environment variables. For example, the implicit cwd is captured as a
+/// `ContainingPackage(path)` selector inside [`PackageQuery`], so two
+/// queries from different directories compare as unequal even though the
+/// user typed the same CLI arguments.
+///
+/// This property is essential for the **skip rule** in task planning, which
+/// compares the nested query against the parent query with `==`. If any
+/// external context leaked into the comparison (or was excluded from it),
+/// the skip rule would either miss legitimate recursion or incorrectly
+/// suppress distinct expansions.
+#[derive(Debug, PartialEq)]
 pub struct TaskQuery {
     /// Which packages to select.
     pub package_query: PackageQuery,