@vzn/vx 0.0.651 → 0.0.653

package/src/workspace/config-schema.ts

@@ -23,6 +23,7 @@ import {
   UserError,
   BUN_GLOB_WILDCARDS,
   EXTGLOB,
+  braceAlternatives,
   braceRange,
   BRACE_RANGE_LIMIT,
   anyTaskGlob,
@@ -115,7 +116,7 @@ const oneOf = (values: readonly string[]): string =>
 
 function validateInputStability(stability: unknown, at: string): void {
   if (typeof stability !== 'object' || stability === null || Array.isArray(stability)) {
-    throw new UserError(`${at} must be an object — \`inputStability: { strategy: 'mutable' }\``)
+    throw new UserError(`${at} must be an object — \`stability: { strategy: 'mutable' }\``)
   }
   assertKnownFields(stability, INPUT_STABILITY_FIELDS, at)
   const { strategy, severity } = stability as Record<string, unknown>
@@ -128,13 +129,13 @@ function validateInputStability(stability: unknown, at: string): void {
 }
 
 /**
- * `VX_CACHE_INPUT_STABILITY_STRATEGY` and `_SEVERITY`, which override every
- * task's `cache.inputStability` for the run: each undefined when unset or
+ * `VX_INPUTS_STABILITY_STRATEGY` and `_SEVERITY`, which override every
+ * task's `inputs.stability` for the run: each undefined when unset or
  * empty, refused when it names no value.
  */
 export function inputStabilityEnv(): InputStability {
-  const strategy = settingEnv('cache.inputStability.strategy') as InputStability['strategy']
-  const severity = settingEnv('cache.inputStability.severity') as InputStability['severity']
+  const strategy = settingEnv('inputs.stability.strategy') as InputStability['strategy']
+  const severity = settingEnv('inputs.stability.severity') as InputStability['severity']
   return {
     ...(strategy !== undefined ? { strategy } : {}),
     ...(severity !== undefined ? { severity } : {}),
@@ -179,15 +180,17 @@ function validateSettingsAt(value: unknown, at: string, configPath: string): voi
     }
     return
   }
-  if (at === 'run.rules.dependencies') validateDependencyRules(value, where)
+  if (at === 'run.rules.dependencies') validateDependencyRules(value, where, configPath)
   else validateSettingValue(value, at, where)
 }
 
 const RULE_FIELDS = new Set(['from', 'allow', 'deny'])
 
-function validateDependencyRules(value: unknown, where: string): void {
+function validateDependencyRules(value: unknown, where: string, configPath: string): void {
   const shape = `an array of { from, allow?, deny? }, each a selector like 'tag:app' or '@acme/*'`
   if (!Array.isArray(value)) throw new UserError(`${where} must be ${shape}`)
+  // The whole path inside one code span, as the frame reads a setting.
+  const at = (i: number, rest = '') => `${configPath}: \`run.rules.dependencies[${i}]${rest}\``
   const selector = (v: unknown) => typeof v === 'string' && v.trim() !== '' && v !== 'tag:'
   const matchable = (v: string, field: string) => {
     const why = ruleSelectorProblem(v)
@@ -198,24 +201,24 @@ function validateDependencyRules(value: unknown, where: string): void {
       )
   }
   for (const [i, rule] of (value as unknown[]).entries()) {
-    const at = `${where}[${i}]`
     if (typeof rule !== 'object' || rule === null || Array.isArray(rule))
-      throw new UserError(`${at} must be { from, allow?, deny? }`)
-    assertKnownFields(rule, RULE_FIELDS, at)
+      throw new UserError(`${at(i)} must be { from, allow?, deny? }`)
+    assertKnownFields(rule, RULE_FIELDS, at(i))
     const { from, allow, deny } = rule as Record<string, unknown>
-    if (!selector(from)) throw new UserError(`${at}.from must be a selector like 'tag:app'`)
-    matchable(from as string, `${at}.from`)
+    if (!selector(from)) throw new UserError(`${at(i, '.from')} must be a selector like 'tag:app'`)
+    matchable(from as string, at(i, '.from'))
     for (const [k, list] of [
       ['allow', allow],
       ['deny', deny],
     ] as const) {
+      const field = at(i, `.${k}`)
       if (list !== undefined && (!Array.isArray(list) || !list.every(selector)))
-        throw new UserError(`${at}.${k} must be an array of selectors like 'tag:lib'`)
-      for (const [j, v] of ((list ?? []) as string[]).entries()) matchable(v, `${at}.${k}[${j}]`)
+        throw new UserError(`${field} must be an array of selectors like 'tag:lib'`)
+      for (const [j, v] of ((list ?? []) as string[]).entries()) matchable(v, at(i, `.${k}[${j}]`))
     }
     // A rule that says nothing reads as a constraint and checks nothing.
     if (allow === undefined && deny === undefined)
-      throw new UserError(`${at} names neither \`allow\` nor \`deny\``)
+      throw new UserError(`${at(i)} names neither \`allow\` nor \`deny\``)
   }
 }
 
@@ -231,6 +234,8 @@ function ruleSelectorProblem(s: string): string | null {
   // The root's own name, which the filter reads as the root's directory.
   if (s === ROOT_NAME) return null
   if (s.startsWith('!')) return "starts with '!', which a filter reads as an exclusion"
+  // The filter parser refuses one, which the catch below would read as a walk.
+  if (hasControl(s)) return 'holds a control character'
   const walk = "starts or ends with '...', which a filter reads as a dependency walk"
   let f: ReturnType<typeof parseFilter>
   try {
@@ -512,12 +517,14 @@ export function validateProjectConfig(
   config: ProjectConfig,
   configPath: string,
   ownConfig: string | null = configPath,
+  /** The caller refused non-JSON values already and passes a JSON copy (project-loader.ts). */
+  jsonCopy = false,
 ): void {
   // Before the schema, on the object as it stands: the key folds its JSON,
   // so a value JSON cannot carry is refused here and in the config worker
   // alike (json-data.ts). A plugin's `project` edit and a lock entry cross
   // this line too.
-  const [nonJson] = nonJsonPaths(config)
+  const [nonJson] = jsonCopy ? [] : nonJsonPaths(config)
   if (nonJson !== undefined) throw new UserError(nonJsonMessage(configPath, nonJson))
   // The top level too: `task:` (singular) loaded as a project with no
   // tasks and every request against it said "no projects declare".
@@ -590,9 +597,18 @@ export function validateProjectConfig(
     const exec = (task as { exec?: unknown }).exec
     const dependsOn = (task as { dependsOn?: unknown }).dependsOn
     const cache = (task as { cache?: unknown }).cache
+    if (cache !== undefined && typeof cache !== 'boolean') {
+      throw new UserError(`${where}.cache must be true or false`)
+    }
     if (exec !== undefined) {
       if (typeof exec !== 'object' || exec === null) {
-        throw new UserError(`${where}.exec must be an object with a \`command\` string`)
+        // A command written as the exec itself, as the task-as-a-string
+        // refusal above spells its fix.
+        throw new UserError(
+          typeof exec === 'string'
+            ? `${where}.exec must be an object — a command is { exec: { command: ${JSON.stringify(exec)} } }`
+            : `${where}.exec must be an object with a \`command\` string`,
+        )
       }
       assertKnownFields(exec, EXEC_FIELDS, `${where}.exec`)
       const sandbox = (exec as { sandbox?: unknown }).sandbox
@@ -623,9 +639,9 @@ export function validateProjectConfig(
       // Documented and never held: an uncached 'only' task loaded, and the
       // REAPI executor refused it at run time for want of described inputs
       // (item 1001).
-      if (remote === 'only' && cache === undefined) {
+      if (remote === 'only' && cache !== true) {
         throw new UserError(
-          `${where}.exec.remote 'only' needs \`cache\`: its inputs are what a worker reproduces ` +
+          `${where}.exec.remote 'only' needs \`cache: true\`: its inputs are what a worker reproduces ` +
             `and its key is the address of its remote record`,
         )
       }
@@ -643,11 +659,33 @@ export function validateProjectConfig(
           )
         }
       }
+      const worker = (exec as { worker?: unknown }).worker
+      if (worker !== undefined && (typeof worker !== 'string' || worker.trim().length === 0)) {
+        throw new UserError(`${where}.exec.worker must be a worker type's name (or omitted)`)
+      }
       const env = (exec as { env?: unknown }).env
       if (env !== undefined) {
         if (typeof env !== 'object' || env === null) {
           throw new UserError(`${where}.exec.env must be an object (or omitted)`)
         }
+        // `env: { NODE_ENV: 'production' }` (Turbo's and Nx's shape): name
+        // the level the variable belongs at, not only the allowed fields.
+        const plain = Array.isArray(env)
+          ? undefined
+          : Object.entries(env).find(
+              ([k, v]) =>
+                !ENV_FIELDS.has(k) &&
+                // `passthrough` is a typo of a field, not a variable.
+                nearest(k, ENV_FIELDS) === undefined &&
+                ['string', 'number', 'boolean'].includes(typeof v),
+            )
+        if (plain !== undefined) {
+          throw new UserError(
+            `${where}.exec.env has unknown field "${plain[0]}" ` +
+              `(allowed: ${[...ENV_FIELDS].sort().join(', ')}) — vx spells it ` +
+              `exec.env.define: { ${plain[0]}: ${JSON.stringify(String(plain[1]))} }`,
+          )
+        }
         // `env: { set: {...} }` loaded and defined nothing — the one level
         // without this check until 2026-09-10 (tests/schema-unknown-keys).
         assertKnownFields(env, ENV_FIELDS, `${where}.exec.env`)
@@ -712,7 +750,7 @@ export function validateProjectConfig(
         throw new UserError(`${where}.exec.interactive must be a boolean (or omitted)`)
       }
       if (interactive === true) {
-        if (cache !== undefined) {
+        if (cache === true) {
           throw new UserError(
             `${where}: \`cache\` is not allowed on an interactive task — what it does ` +
               `depends on what is typed, which no key holds`,
@@ -765,7 +803,7 @@ export function validateProjectConfig(
             )
           }
         }
-        if (cache !== undefined) {
+        if (cache === true) {
           throw new UserError(
             `${where}: \`cache\` is not allowed on a persistent task — persistent tasks ` +
               `don't terminate, so there's no exit to cache`,
@@ -801,9 +839,12 @@ export function validateProjectConfig(
     }
     if (dependsOn !== undefined) {
       if (!Array.isArray(dependsOn) || dependsOn.some((s) => typeof s !== 'string')) {
+        // One name, not in a list: the fix is that list.
         throw new UserError(
-          `${where}.dependsOn must be an array of strings ` +
-            `(Turbo/Nx micro-syntax: 'name', '^name', 'pkg#name')`,
+          typeof dependsOn === 'string'
+            ? `${where}.dependsOn must be an array — write dependsOn: [${JSON.stringify(dependsOn)}]`
+            : `${where}.dependsOn must be an array of strings ` +
+                `(Turbo/Nx micro-syntax: 'name', '^name', 'pkg#name')`,
         )
       }
     }
@@ -919,6 +960,10 @@ export function validateProjectConfig(
             throw err
           }
         }
+        // The selection starts empty and a `!` entry only subtracts, so a
+        // list of negations folded no dependency and the key stopped moving
+        // with every upstream, as a negation-only inputs.files does.
+        assertTaskFiltersNotNegationOnly(taskFilters, `${where}.inputs.tasks`)
         assertFilterNamesDeclaredDeps(taskFilters, task.dependsOn, where)
       }
       for (const field of ['runtime', 'workspaceRuntime'] as const) {
@@ -943,16 +988,8 @@ export function validateProjectConfig(
         validateWorkspaceGlobs(wsInputs, `${where}.inputs.workspaceFiles`, true)
       }
     }
-    if (cache !== undefined) {
-      if (typeof cache !== 'object' || cache === null) {
-        throw new UserError(
-          `${where}.cache must be an object when present — \`inputs: { files: [...] }, cache: { outputs: { files: [...] } }\`, or no \`cache\` for a task that never caches`,
-        )
-      }
-      assertKnownFields(cache, CACHE_FIELDS, `${where}.cache`)
-      const stability = (cache as { inputStability?: unknown }).inputStability
-      if (stability !== undefined)
-        validateInputStability(stability, `${where}.cache.inputStability`)
+    const outputs = (task as { outputs?: unknown }).outputs
+    if (cache === true) {
       // The key is the task's inputs, and a group runs nothing to cache.
       if (exec === undefined) {
         throw new UserError(
@@ -964,23 +1001,38 @@ export function validateProjectConfig(
           `${where}: \`cache\` needs \`inputs\` — the key is the task's inputs, \`inputs: { files: [...] }\``,
         )
       }
-      const outputs = (cache as { outputs?: unknown }).outputs
-      if (outputs === undefined || outputs === null) {
-        throw new UserError(`${where}.cache.outputs is required when \`cache\` is set`)
+      if (outputs === undefined) {
+        throw new UserError(
+          `${where}: \`cache\` needs \`outputs\` — what the task produces, \`outputs: { files: [...] }\` (\`[]\` for none)`,
+        )
+      }
+    }
+    const stability = (inputs as { stability?: unknown } | undefined)?.stability
+    if (stability !== undefined) {
+      validateInputStability(stability, `${where}.inputs.stability`)
+      if (exec === undefined) {
+        throw new UserError(
+          `${where}.inputs.stability needs \`exec\` — a task with no command runs nothing that could write its inputs`,
+        )
+      }
+    }
+    if (outputs !== undefined) {
+      if (outputs === null || typeof outputs !== 'object') {
+        throw new UserError(`${where}.outputs must be an object — \`outputs: { files: [...] }\``)
       }
-      if (typeof outputs !== 'object') {
+      assertKnownFields(outputs, OUTPUT_FIELDS, `${where}.outputs`)
+      if (exec === undefined) {
         throw new UserError(
-          `${where}.cache.outputs must be an object — \`outputs: { files: [...] }\``,
+          `${where}.outputs needs \`exec\` — a task with no command writes nothing`,
         )
       }
-      assertKnownFields(outputs, CACHE_OUTPUT_FIELDS, `${where}.cache.outputs`)
       const clean = (outputs as { clean?: unknown }).clean
       if (clean !== undefined && typeof clean !== 'boolean') {
-        throw new UserError(`${where}.cache.outputs.clean must be true or false`)
+        throw new UserError(`${where}.outputs.clean must be true or false`)
       }
       const outFiles = (outputs as { files?: unknown }).files
       if (!Array.isArray(outFiles)) {
-        throw new UserError(`${where}.cache.outputs.files must be an array of glob strings`)
+        throw new UserError(`${where}.outputs.files must be an array of glob strings`)
       }
       // Reject zero-length strings and absolute paths up front.
       // Both reach `resolveOutputs` as undefined behavior; the error
@@ -988,26 +1040,26 @@ export function validateProjectConfig(
       // at the user's config. Fail loud at load time.
       for (const g of outFiles as unknown[]) {
         if (typeof g !== 'string' || g.length === 0) {
-          throw new UserError(`${where}.cache.outputs.files must be an array of non-empty strings`)
+          throw new UserError(`${where}.outputs.files must be an array of non-empty strings`)
         }
         if (isAbsoluteGlob(g)) {
           throw new UserError(
-            `${where}.cache.outputs.files: absolute paths are not allowed (got "${g}") — ` +
+            `${where}.outputs.files: absolute paths are not allowed (got "${g}") — ` +
               `outputs must be project-relative globs`,
           )
         }
         if (hasParentSegment(g)) {
           throw new UserError(
-            `${where}.cache.outputs.files: '..' path segments are not allowed (got "${g}") — ` +
+            `${where}.outputs.files: '..' path segments are not allowed (got "${g}") — ` +
               `outputs must stay within the project (vx clears a task's outputs before it runs, ` +
               `so a glob that escapes the project would delete files outside it)`,
           )
         }
-        assertPosixGlob(g, `${where}.cache.outputs.files`, 'project')
-        assertNoForeignToken(g, `${where}.cache.outputs.files`)
+        assertPosixGlob(g, `${where}.outputs.files`, 'project')
+        assertNoForeignToken(g, `${where}.outputs.files`)
         if (namesDirItself(g)) {
           throw new UserError(
-            `${where}.cache.outputs.files: "${g}" names the project directory itself and selects nothing — ` +
+            `${where}.outputs.files: "${g}" names the project directory itself and selects nothing — ` +
               `name the directory the task writes, such as "dist/**"`,
           )
         }
@@ -1016,31 +1068,31 @@ export function validateProjectConfig(
         // a "corrupt artifact", dropped and run again.
         if (!g.startsWith('!') && normalizeGlob(g).split('/')[0] === 'workspace-outputs') {
           throw new UserError(
-            `${where}.cache.outputs.files: "${g}" is under workspace-outputs/, a name vx's ` +
+            `${where}.outputs.files: "${g}" is under workspace-outputs/, a name vx's ` +
               `artifacts reserve for outputs.workspaceFiles — write the task's files to another directory`,
           )
         }
         // A `!` entry takes a path back from the outputs (A-44): it is not
         // cleaned, saved or restored, and it stays an input.
-        assertNotDoubleNegated(g, `${where}.cache.outputs.files`)
+        assertNotDoubleNegated(g, `${where}.outputs.files`)
         // Taken back by a `!`, the file is never cleaned or restored.
         const own = g.startsWith('!')
           ? undefined
           : ownFilesCovered(g, ownConfig).find((f) => !takenBack(outFiles as unknown[], f))
         if (own !== undefined) {
           throw new UserError(
-            `${where}.cache.outputs.files: "${g}" covers the project's own ${own} — vx deletes a ` +
+            `${where}.outputs.files: "${g}" covers the project's own ${own} — vx deletes a ` +
               `task's outputs before it runs and restores them on a hit, so the project would lose ` +
               `its config. Name the directory the task writes, such as "dist/**", ` +
               `or take the file back with "!${own}".`,
           )
         }
       }
-      assertOutputsNotNegationOnly(outFiles as string[], `${where}.cache.outputs.files`)
-      assertNoLiteralTakenBack(outFiles as string[], `${where}.cache.outputs.files`, OUTPUT_LOST)
+      assertOutputsNotNegationOnly(outFiles as string[], `${where}.outputs.files`)
+      assertNoLiteralTakenBack(outFiles as string[], `${where}.outputs.files`, OUTPUT_LOST)
       const wsOutputs = (outputs as { workspaceFiles?: unknown }).workspaceFiles
       if (wsOutputs !== undefined) {
-        validateWorkspaceGlobs(wsOutputs, `${where}.cache.outputs.workspaceFiles`, false)
+        validateWorkspaceGlobs(wsOutputs, `${where}.outputs.workspaceFiles`, false)
       }
     }
   }
@@ -1055,7 +1107,7 @@ export function validateProjectConfig(
 // `tasks` first: `nearest` breaks a tie by order, and `taks` is one edit
 // from both.
 const PROJECT_FIELDS = new Set(['name', 'tasks', 'tags'])
-const TASK_FIELDS = new Set(['description', 'exec', 'dependsOn', 'inputs', 'cache'])
+const TASK_FIELDS = new Set(['description', 'exec', 'dependsOn', 'inputs', 'outputs', 'cache'])
 const EXEC_FIELDS = new Set([
   'command',
   'env',
@@ -1066,10 +1118,10 @@ const EXEC_FIELDS = new Set([
   'remote',
   'sandbox',
   'platforms',
+  'worker',
 ])
 const PERSISTENT_FIELDS = new Set(['readyWhen'])
 const ENV_FIELDS = new Set(['passThrough', 'define', 'secret'])
-const CACHE_FIELDS = new Set(['outputs', 'inputStability'])
 const INPUT_FIELDS = new Set([
   'files',
   'workspaceFiles',
@@ -1077,8 +1129,9 @@ const INPUT_FIELDS = new Set([
   'tasks',
   'runtime',
   'workspaceRuntime',
+  'stability',
 ])
-const CACHE_OUTPUT_FIELDS = new Set(['files', 'workspaceFiles', 'clean'])
+const OUTPUT_FIELDS = new Set(['files', 'workspaceFiles', 'clean'])
 
 /**
  * Another runner's spelling of a field vx has under another name, by the
@@ -1090,8 +1143,10 @@ const FOREIGN_FIELDS: ReadonlyMap<ReadonlySet<string>, Readonly<Record<string, s
   [
     TASK_FIELDS,
     {
-      outputs: '`cache.outputs.files`',
       env: '`inputs.env` (to key the task on a variable) or `exec.env` (to pass one)',
+      // wireit's script keys.
+      output: '`outputs.files`',
+      dependencies: "`dependsOn` (an upstream's key goes into this one)",
       passThroughEnv: '`exec.env.passThrough`',
       command: '`exec.command`',
       cmd: '`exec.command`',
@@ -1128,18 +1183,6 @@ const FOREIGN_FIELDS: ReadonlyMap<ReadonlySet<string>, Readonly<Record<string, s
       shell: 'no field: `command` always runs in a shell',
     },
   ],
-  // wireit's `files` / `output` and include-style spellings written into
-  // a cache block, refused with no word on where they go (D-118).
-  [
-    CACHE_FIELDS,
-    {
-      files: "the task's `inputs.files`",
-      output: '`outputs.files`',
-      env: "the task's `inputs.env`",
-      dependencies: "the task's `dependsOn` (an upstream's key goes into this one)",
-      enabled: 'no field: a task with a `cache` block caches, one without runs every time',
-    },
-  ],
   [
     INPUT_FIELDS,
     {
@@ -1151,7 +1194,7 @@ const FOREIGN_FIELDS: ReadonlyMap<ReadonlySet<string>, Readonly<Record<string, s
     },
   ],
   [
-    CACHE_OUTPUT_FIELDS,
+    OUTPUT_FIELDS,
     {
       globs: '`files`',
       include: '`files`',
@@ -1176,12 +1219,11 @@ const FOREIGN_FIELDS: ReadonlyMap<ReadonlySet<string>, Readonly<Record<string, s
       sourceRoot: "a task's `inputs.files`",
       projectType: 'no field: vx runs every project alike',
       ...Object.fromEntries(
-        ['dependsOn', 'inputs', 'cache', 'exec', 'description'].map((k) => [
+        ['dependsOn', 'inputs', 'outputs', 'cache', 'exec', 'description'].map((k) => [
           k,
           `\`tasks.<name>.${k}\`: a project holds tasks, and each task its own \`${k}\``,
         ]),
       ),
-      outputs: '`tasks.<name>.cache.outputs.files`',
       env: '`tasks.<name>.inputs.env` (to key a task on it) or `tasks.<name>.exec.env`',
     },
   ],
@@ -1252,7 +1294,7 @@ function nestedHome(allowed: ReadonlySet<string>, key: string): string | undefin
   for (const [field, own] of [
     ['exec', EXEC_FIELDS],
     ['inputs', INPUT_FIELDS],
-    ['cache', CACHE_FIELDS],
+    ['outputs', OUTPUT_FIELDS],
   ] as const) {
     if (own.has(key)) return `\`${field}.${key}\``
   }
@@ -1273,7 +1315,11 @@ function assertKnownFields(value: object, allowed: ReadonlySet<string>, where: s
     if (!allowed.has(key)) {
       // The nearest accepted spelling first: the list says what the level
       // takes, the hint says which one was meant.
-      const foreign = FOREIGN_FIELDS.get(allowed)?.[key] ?? nestedHome(allowed, key)
+      // Own keys only: `constructor` read Object's and printed its source.
+      const spellings = FOREIGN_FIELDS.get(allowed)
+      const foreign =
+        (spellings !== undefined && Object.hasOwn(spellings, key) ? spellings[key] : undefined) ??
+        nestedHome(allowed, key)
       const near =
         nearest(key, allowed) ?? (allowed === WORKSPACE_FIELDS ? nearestSetting(key) : undefined)
       throw new UserError(
@@ -1383,14 +1429,25 @@ function assertNoForeignToken(glob: string, where: string): void {
  * and names both.
  */
 function assertNoGluedGlobstar(glob: string, where: string): void {
+  if (gluesGlobstar(glob)) throw gluedGlobstar(glob, `"${glob}"`, where)
+  // Split on `{` `}` `,` alone, `src/{a,**}.ts` passed and expanded to
+  // `src/**.ts`, one level.
+  const alt = braceAlternatives(glob).find(gluesGlobstar)
+  if (alt !== undefined) throw gluedGlobstar(alt, `"${glob}" expands to "${alt}": that`, where)
+}
+
+function gluesGlobstar(glob: string): boolean {
   const body = glob.startsWith('!') ? glob.slice(1) : glob
-  if (!body.split(/[/{},]/).some((seg) => seg.includes('**') && /[^*]/.test(seg))) return
+  return body.split(/[/{},]/).some((seg) => seg.includes('**') && /[^*]/.test(seg))
+}
+
+function gluedGlobstar(glob: string, subject: string, where: string): UserError {
   const deep = glob.replace(/\*\*([^*/{},]+)/g, '**/*$1').replace(/([^*/{},]+)\*\*/g, '$1*/**')
   const one = glob.replace(/\*{2,}/g, (run, at: number) =>
     /[^*/{},]/.test(glob[at - 1] ?? '') || /[^*/{},]/.test(glob[at + run.length] ?? '') ? '*' : run,
   )
-  throw new UserError(
-    `${where}: "${glob}" glues ** to other text in one path segment, which vx's glob engine ` +
+  return new UserError(
+    `${where}: ${subject} glues ** to other text in one path segment, which vx's glob engine ` +
       `reads as one *, a single directory level. Write "${deep}" for every depth, or "${one}" ` +
       `for one level.`,
   )
@@ -1538,7 +1595,7 @@ function assertInputGlob(glob: string, where: string): void {
   if (glob.replace(/^!/, '').split('/').includes('.git')) {
     throw new UserError(
       `${where}: "${glob}" names a path under .git, which git never lists, so it keys nothing — ` +
-        `inputs are the repository's files`,
+        `inputs are the workspace's files`,
     )
   }
 }
@@ -1662,8 +1719,8 @@ function isEnvName(name: unknown): name is string {
  * A task name `dependsOn`, `inputs.tasks` and the CLI can name. Each
  * refused shape loaded and could not be referenced: `x#y` read as project
  * `x`, `^gen` as every dependency's `gen`, a `*` as a pattern, `''` ran
- * under `--all` as `a#` and `vx run a#` refused it, and a padded name was
- * trimmed away by the reader (item 1000).
+ * under `--all` as `a#` and `vx run a#` refused it, `-x` as a flag, and a
+ * padded name was trimmed away by the reader (item 1000).
  */
 function assertTaskName(name: string, configPath: string): void {
   const why = taskNameProblem(name)
@@ -1686,9 +1743,11 @@ export function taskNameProblem(name: string): string | null {
           ? "holds '*', which makes it a pattern"
           : name.startsWith('^') || name.startsWith('!')
             ? `starts with '${name[0]}', which names dependencies' tasks or negates`
-            : hasControl(name)
-              ? 'holds a control character'
-              : null
+            : name.startsWith('-')
+              ? "starts with '-', which the CLI reads as a flag"
+              : hasControl(name)
+                ? 'holds a control character'
+                : null
 }
 
 /**
@@ -1699,6 +1758,9 @@ export function taskNameProblem(name: string): string | null {
 function tagProblem(tag: string): string | null {
   if (tag.trim() !== tag) return 'has surrounding whitespace'
   if (tag.includes('*')) return "holds '*', which makes it a pattern"
+  // Refused by the caller in its own words; the filter parser refuses one
+  // too, which the catch below would read as a walk.
+  if (hasControl(tag)) return null
   const walk = "ends in '...', which a filter reads as a dependency walk"
   let f: ReturnType<typeof parseFilter>
   try {
@@ -1737,6 +1799,18 @@ function assertNotNegationOnly(globs: readonly string[], where: string): void {
   )
 }
 
+function assertTaskFiltersNotNegationOnly(filters: readonly string[], where: string): void {
+  if (filters.length === 0) return
+  if (filters.some((f) => !f.startsWith('!'))) return
+  throw new UserError(
+    `${where}: every entry is a negation, which selects NOTHING (got ${JSON.stringify(filters)}) — ` +
+      `negations only subtract from the dependencies a positive entry already selected, so this ` +
+      `task would fold no upstream hash and its cache key would stop tracking its dependencies. ` +
+      `Add the positive entry you meant, e.g. ['*', '^*', ${JSON.stringify(filters[0])}], ` +
+      `or use [] to decouple on purpose.`,
+  )
+}
+
 /**
  * A `!` entry subtracts wherever it sits in the list, so a file named
  * outright after it (`['src/**', '!src/gen/**', 'src/gen/keep.ts']`) never
@@ -1828,6 +1902,7 @@ const SANDBOX_FIELDS = new Set([
   'ignore',
   'weakerWhenNested',
   'weakerNetworkIsolation',
+  'hermetic',
 ])
 const GRANT_PATH_FIELDS = ['read', 'write'] as const
 const GRANT_NAME_FIELDS = ['systemInfo', 'machLookup'] as const
@@ -1855,6 +1930,19 @@ function assertStringArray(v: unknown, where: string): void {
   }
 }
 
+/**
+ * Only `~` and `~/…` mean the home: `~root/x/` was read as `$HOME/root/x`,
+ * and vx created that directory on the host.
+ */
+function assertOwnHome(v: readonly string[], where: string): void {
+  const other = v.find((p) => p.startsWith('~') && p !== '~' && !p.startsWith('~/'))
+  if (other === undefined) return
+  throw new UserError(
+    `${where}: ${JSON.stringify(other)} names a user's home, which vx does not expand — ` +
+      `write '~/…' for your own home, or an absolute path`,
+  )
+}
+
 /**
  * Validate a `sandbox: {...}` block — one capability shape, whatever the
  * platform ends up doing with it. Unknown keys are refused rather than
@@ -1871,7 +1959,7 @@ function validateSandbox(sandbox: unknown, where: string): void {
   assertKnownFields(sandbox, SANDBOX_FIELDS, `${where}.sandbox`)
   const obj = sandbox as Record<string, unknown>
 
-  for (const flag of ['weakerWhenNested', 'weakerNetworkIsolation']) {
+  for (const flag of ['weakerWhenNested', 'weakerNetworkIsolation', 'hermetic']) {
     if (obj[flag] !== undefined && typeof obj[flag] !== 'boolean') {
       throw new UserError(`${where}.sandbox.${flag} must be a boolean`)
     }
@@ -1887,7 +1975,22 @@ function validateSandbox(sandbox: unknown, where: string): void {
     for (const f of GRANT_PATH_FIELDS) {
       // Patterns are allowed here: macOS matches them natively, Linux
       // expands them against the filesystem at resolve time.
-      if (g[f] !== undefined) assertStringArray(g[f], `${where}.sandbox.allow.${f}`)
+      if (g[f] === undefined) continue
+      assertStringArray(g[f], `${where}.sandbox.allow.${f}`)
+      assertOwnHome(g[f] as string[], `${where}.sandbox.allow.${f}`)
+    }
+    // SRT's Linux observer reports a write's path with each control
+    // character turned into a space, so a write a grant holding one covers
+    // read as a violation of the path spelled with a space, and a real
+    // write there reads the same: no match passes one and not the other.
+    // Reads are traced by strace, which escapes them.
+    const ctl = ((g['write'] as string[] | undefined) ?? []).find(hasControl)
+    if (ctl !== undefined) {
+      throw new UserError(
+        `${where}.sandbox.allow.write: ${JSON.stringify(ctl)} holds a control character, ` +
+          `which the Linux sandbox's report of a write does not keep (it spells a tab as a ` +
+          `space), so a write under it cannot be told from a refused one — rename it`,
+      )
     }
     for (const f of GRANT_NAME_FIELDS) {
       if (g[f] !== undefined) assertStringArray(g[f], `${where}.sandbox.allow.${f}`)
@@ -1944,7 +2047,10 @@ function validateSandbox(sandbox: unknown, where: string): void {
     // Patterns, not prefixes — `ignore` is vx's own filter over lines it
     // already holds, so a glob costs nothing and works on every platform.
     for (const f of IGNORE_FIELDS) {
-      if (g[f] !== undefined) assertStringArray(g[f], `${where}.sandbox.ignore.${f}`)
+      if (g[f] === undefined) continue
+      assertStringArray(g[f], `${where}.sandbox.ignore.${f}`)
+      if (f === 'read' || f === 'write')
+        assertOwnHome(g[f] as string[], `${where}.sandbox.ignore.${f}`)
     }
   }
 }

package/src/workspace/dependencies-lock.ts

@@ -11,8 +11,8 @@
 // changed lockfile's base digests are there, so the base side is never
 // parsed. `vx lock --check` holds it to a fresh derivation.
 
-import { rename, rm } from 'node:fs/promises'
 import path from 'node:path'
+import type { PendingWrite } from '../util/index.js'
 import type { ProjectMeta } from './workspace.js'
 import { lockKey } from './lockfile.js'
 import { type LoadReads, readOnce } from './load-reads.js'
@@ -90,19 +90,12 @@ function dependenciesLockText(lock: DependenciesLock): string {
   return `${JSON.stringify(lock)}\n`
 }
 
-/** Written beside its name and renamed over it, as `writeLockfile`: a reader never sees half a file. */
-export async function writeDependenciesLock(root: string, lock: DependenciesLock): Promise<void> {
-  const file = path.join(root, DEPENDENCIES_LOCK_NAME)
-  const tmp = `${file}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`
-  try {
-    await Bun.write(tmp, dependenciesLockText(lock))
-    await rename(tmp, file)
-  } catch (err) {
-    await rm(tmp, { force: true }).catch(() => {})
-    const e = err as NodeJS.ErrnoException
-    if (typeof e.message === 'string') e.message = e.message.split(tmp).join(file)
-    if (e.path === tmp) e.path = file
-    throw err
+/** The dependency lock's file and bytes, for `writeAllOrNone`. */
+export function dependenciesLockWrite(root: string, lock: DependenciesLock): PendingWrite {
+  return {
+    file: path.join(root, DEPENDENCIES_LOCK_NAME),
+    text: dependenciesLockText(lock),
+    shown: DEPENDENCIES_LOCK_NAME,
   }
 }