@vzn/vx 0.0.591 → 0.0.595

package/src/orchestrator/sandbox-request.ts

@@ -24,7 +24,7 @@ import {
   type SandboxViolation,
 } from '../exec/index.js'
 import type { TaskNode } from '../graph/index.js'
-import { grantPrefix, UserError } from '../util/index.js'
+import { grantPrefix, relPosix, UserError } from '../util/index.js'
 import { WORKSPACE_FINGERPRINT_FILES } from '../workspace/index.js'
 
 /**
@@ -350,6 +350,7 @@ async function linkedDeps(
   keyed: ReadonlySet<string> | undefined,
 ): Promise<{ granted: string[]; withheld: WithheldLink[] }> {
   const [self, root] = await Promise.all([realpath(projectDir), realpath(workspaceRoot)])
+  const realDirs = dirs.map(toRealPath)
   const scan = async (dir: string, scope: string): Promise<Array<[string, string, string]>> => {
     const found: Array<[target: string, link: string, name: string]> = []
     const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
@@ -359,7 +360,7 @@ async function linkedDeps(
         const target = await realpath(full).catch(() => undefined)
         if (
           target !== undefined &&
-          !dirs.some((d) => atOrUnder(target, d)) &&
+          !realDirs.some((d) => atOrUnder(target, d)) &&
           !atOrUnder(self, target)
         ) {
           found.push([target, full, scope + e.name])
@@ -388,8 +389,8 @@ async function linkedDeps(
       withheld.push({
         dir: target,
         name,
-        target: posixRel(root, target),
-        link: posixRel(workspaceRoot, link),
+        target: relPosix(root, target),
+        link: relPosix(workspaceRoot, link),
       })
   }
   return { granted, withheld }
@@ -421,11 +422,6 @@ export function reachedWithheld(
   )
 }
 
-/** `p` relative to `from`, with `/` separators. */
-function posixRel(from: string, p: string): string {
-  return path.relative(from, p).split(path.sep).join('/')
-}
-
 /**
  * Ensure each declared write path exists on the host as either an empty
  * file (a literal path) or a directory (a glob's static prefix, or a
@@ -565,7 +561,7 @@ export function placeholderSweeper(placeholders: readonly Placeholder[]): () =>
  * never reddens a pass and never buries a real denial.
  */
 export function untouchedPlaceholderLine(projectDir: string, placeholder: string): string {
-  const rel = path.relative(projectDir, placeholder).split(path.sep).join('/')
+  const rel = relPosix(projectDir, placeholder)
   return (
     `vx: the sandbox write grant \`${rel}\` named nothing on disk, so vx bound it as an empty ` +
     `file, which the task never wrote (removed again). If the task creates a directory there ` +

package/src/orchestrator/signals.ts

@@ -14,7 +14,7 @@
 // them to the runner around every spawn.
 
 import { signalExitCode } from '../exec/index.js'
-import { killGraceMs, settleWithin } from '../util/index.js'
+import { claimExitForSignal, killGraceMs, settleWithin } from '../util/index.js'
 import { holdGroups, killTree, untilGroupsGone } from '../exec/index.js'
 import type { Logger } from './logger.js'
 
@@ -69,7 +69,9 @@ export async function terminateChildren(
   signal: ForwardedSignal = 'SIGTERM',
   graceMs: number = killGraceMs(SIGNAL_SHUTDOWN_GRACE_MS),
 ): Promise<void> {
-  const children = live()
+  // A ready server is in both of run()'s lists: signalled twice, it read
+  // the second as a repeated Ctrl-C (force quit).
+  const children = [...new Set(live())]
   // On the group guard's list until the sweep below is done: a shell that
   // dies on the signal lets its group go while what it forked runs out
   // the grace (kill-tree.ts, `holdGroups`).
@@ -131,6 +133,7 @@ export function forwardSignals(args: {
     // that ended the run.
     if (stopping !== undefined) exit(stopping)
     stopping = signal
+    claimExitForSignal()
     // Clear the live worker/status region BEFORE exiting so a TTY isn't
     // left with a frozen region in the scrollback. runEnd is idempotent
     // and a no-op for non-TTY loggers.

package/src/orchestrator/summary.ts

@@ -119,6 +119,8 @@ export interface SummaryStats {
   spread: { maxMs: number; minMs: number; sumMs: number; count: number } | null
   /** Tasks an `admit` policy held with a worker free, and the waits summed. Absent with no hold. */
   held?: { count: number; sumMs: number }
+  /** A run of groups only: their names, so `0 tasks` says why. */
+  emptyGroups?: readonly string[]
 }
 
 /**
@@ -213,7 +215,14 @@ export function formatSummarySection(
     // No legend line until the first bucket lands (live: all-gray bar).
     if (taskParts.length > 0) lines.push(legend(taskParts))
   } else {
-    lines.push(row('tasks', dim('0 tasks')))
+    const groups = stats.emptyGroups ?? []
+    // `vx run build` where no project gives build a command runs the default
+    // group alone: say so, or it reads like a selection that matched nothing.
+    const why =
+      groups.length > 0
+        ? ` ${dim('\u00b7')} ${dim(`${groups.join(', ')} ${groups.length === 1 ? 'has' : 'have'} no command in these projects`)}`
+        : ''
+    lines.push(row('tasks', dim('0 tasks') + why))
     // A stop before any task finished still names what it took down.
     if (taskParts.length > 0) lines.push(legend(taskParts))
   }
@@ -368,6 +377,9 @@ export function formatRunSummary(
     .map((o) => o.durationMs)
   const heldOutcomes = outcomes.filter((o) => o.admissionHeldMs !== undefined)
   const notRun = outcomes.filter((o) => neverStarted(o) && !isGroupTask(o.node)).length
+  const emptyGroups = outcomes.every((o) => isGroupTask(o.node))
+    ? [...new Set(outcomes.map((o) => o.node.taskName))]
+    : []
   return formatSummarySection(
     {
       failed: t.failed,
@@ -398,6 +410,7 @@ export function formatRunSummary(
             },
           }
         : {}),
+      ...(emptyGroups.length > 0 ? { emptyGroups } : {}),
     },
     totalMs,
     colors,

package/src/util/index.ts

@@ -49,7 +49,13 @@ export {
   wholeSubtreePrefixes,
   slashBraceExpansions,
 } from './paths.js'
-export { killGraceMs, settleWithin, teardownTimeoutMs } from './settle.js'
+export {
+  claimExitForSignal,
+  exitClaimedBySignal,
+  killGraceMs,
+  settleWithin,
+  teardownTimeoutMs,
+} from './settle.js'
 export { formatBytes, parseDuration, parseSize } from './size.js'
 export {
   cgroupCpuQuota,

package/src/util/secret-mask.ts

@@ -49,6 +49,13 @@ export interface SecretMask {
    * the next chunk or `end`.
    */
   stream(): { push(chunk: string): string; end(): string }
+  /**
+   * `mask` for the two sides of a cut, where the text between them is
+   * gone: a value the cut split leaves a piece at the end of `head` or the
+   * start of `tail` that no whole-value match sees, so each piece is
+   * masked too.
+   */
+  maskCut(head: string, tail: string): [string, string]
 }
 
 /**
@@ -103,8 +110,37 @@ export function secretMask(
     }
     return longest
   }
+  /** The longest head of `text` that is a proper suffix of a value. */
+  const partialHead = (text: string): number => {
+    let longest = 0
+    for (const v of sorted) {
+      for (let k = Math.min(v.length - 1, text.length); k > longest; k--) {
+        if (text.startsWith(v.slice(v.length - k))) {
+          longest = k
+          break
+        }
+      }
+    }
+    return longest
+  }
   return {
     mask,
+    maskCut(head, tail) {
+      let h = head.length - partialTail(head)
+      pattern.lastIndex = 0
+      for (let m = pattern.exec(head); m !== null; m = pattern.exec(head)) {
+        if (m.index < h && m.index + m[0].length > h) h = m.index
+      }
+      let t = partialHead(tail)
+      pattern.lastIndex = 0
+      for (let m = pattern.exec(tail); m !== null; m = pattern.exec(tail)) {
+        if (m.index < t && m.index + m[0].length > t) t = m.index + m[0].length
+      }
+      return [
+        mask(head.slice(0, h)) + (h < head.length ? MASKED : ''),
+        (t > 0 ? MASKED : '') + mask(tail.slice(t)),
+      ]
+    },
     stream() {
       let carry = ''
       return {

package/src/util/settle.ts

@@ -68,3 +68,18 @@ export async function settleWithin(p: Promise<unknown>, ms: number): Promise<boo
     void p.catch(() => {})
   }
 }
+
+// Who ends the process. bin.ts exits once its verb has settled and the
+// streams have ended; a signal's handler exits by itself, with the
+// signal's code, once the run it stopped is done. The verb settles first,
+// with the run's verdict (1), so bin.ts asks before it exits.
+let signalOwnsExit = false
+
+/** A signal's handler will end the process: bin.ts leaves the exit to it. */
+export function claimExitForSignal(): void {
+  signalOwnsExit = true
+}
+
+export function exitClaimedBySignal(): boolean {
+  return signalOwnsExit
+}

package/src/workspace/affected.ts

@@ -19,7 +19,7 @@ import {
   relPosix,
 } from '../util/index.js'
 import { LOCKFILE_NAME } from './lockfile.js'
-import { configImportOwners } from './config-imports.js'
+import { configImportOwners, realpathOr } from './config-imports.js'
 import { configImports } from './config-cache.js'
 import { WORKSPACE_CONFIG_FILENAMES } from './project-loader.js'
 import { bunPatchFiles, WORKSPACE_FINGERPRINT_FILES } from './fingerprint.js'
@@ -176,6 +176,14 @@ export async function affectedChanges(
         `("${since.slice(0, range) || 'HEAD'}"); vx diffs it against the working tree.`,
     )
   }
+  // `^main` is rev-list's exclusion, not a ref: merge-base refused it, it
+  // verified, and `git diff ^main` diffed from main itself, so changes
+  // only main made were selected (`^` is illegal in a ref name).
+  if (since.startsWith('^')) {
+    throw new UserError(
+      `git ref "${since}" is an exclusion, not a ref: pass the base alone ("${since.replace(/^\^+/, '') || 'HEAD'}").`,
+    )
+  }
   // Diff from the MERGE BASE of `since` and HEAD, not from `since` itself:
   // on a branch whose base has moved on, `git diff <base>` reports every
   // file OTHER people changed on the base (over-selection that defeats a
@@ -432,7 +440,17 @@ async function dependentsAtBase(
     ) {
       continue
     }
-    byDir.set(dir, { name: pkg.name, dir, packageJson: pkg, configPath: null })
+    // Today's catalogs, or both graphs would differ on every `catalog:`
+    // entry. A catalog edit is a `pnpm-workspace.yaml` or root manifest
+    // edit, which the fingerprint widening and the root's own change answer.
+    const catalogs = projects[0]?.catalogs
+    byDir.set(dir, {
+      name: pkg.name,
+      dir,
+      packageJson: pkg,
+      configPath: null,
+      ...(catalogs === undefined ? {} : { catalogs }),
+    })
     if (nameNow.get(dir) !== pkg.name) gone.add(pkg.name)
   }
   const now = buildPackageGraph([...projects])
@@ -468,8 +486,10 @@ function parentsOfNewNested(
   projects: readonly ProjectMeta[],
 ): Set<string> {
   const out = new Set<string>()
+  // Keyed NFC: macOS git reports paths NFC (core.precomposeunicode) while a
+  // dir discovered by readdir keeps the spelling it was created with.
   const dirToName = new Map<string, string>()
-  for (const p of projects) dirToName.set(p.dir, p.name)
+  for (const p of projects) dirToName.set(p.dir.normalize('NFC'), p.name)
   for (const [rel, bytes] of atBase) {
     const dir = path.resolve(workspaceRoot, path.posix.dirname(rel))
     if (!dirToName.has(dir)) continue
@@ -570,7 +590,7 @@ async function workspaceConfigChanged(
   if (config === undefined) return false
   const root = realpathSync(workspaceRoot)
   for (const file of await configImports(config)) {
-    if (set.has(path.relative(root, file).split(path.sep).join('/'))) return true
+    if (set.has(relPosix(root, file))) return true
   }
   return false
 }
@@ -613,7 +633,10 @@ async function bytesOrNull(file: string): Promise<Uint8Array | null> {
 /** Run a NUL-separated path-listing git command from the workspace root. */
 async function gitPaths(workspaceRoot: string, cmd: string[]): Promise<string[]> {
   const proc = spawnGit([...cmd], workspaceRoot)
-  const stdout = await new Response(proc.stdout).text()
+  // `Response.text()` strips a leading U+FEFF, the first path's own.
+  const stdout = new TextDecoder('utf-8', { ignoreBOM: true }).decode(
+    await new Response(proc.stdout).bytes(),
+  )
   const stderr = await new Response(proc.stderr).text()
   const exit = await proc.exited
   if (exit !== 0) {
@@ -755,6 +778,17 @@ async function mergeBase(workspaceRoot: string, ref: string): Promise<string> {
   const sha = out.trim()
   if (exit === 0 && sha.length > 0) return sha
   await verifyRef(workspaceRoot, ref)
+  // `<rev>:<path>` names the tree (or blob) at <path>: diffed against the
+  // working tree, its paths miss the <path>/ prefix, and `develop:pkgs`
+  // selected projects nothing had changed, green. A root tree
+  // (`develop^{tree}`, the empty tree) diffs right and stays a base.
+  const sub = /^([^:]*):(?!\/)(.+)$/s.exec(ref)
+  if (sub !== null) {
+    throw new UserError(
+      `git ref "${ref}" names what is at ${sub[2]}, not a commit: vx diffs the whole ` +
+        `workspace, so pass the commit alone ("${sub[1] || 'HEAD'}").`,
+    )
+  }
   return ref
 }
 
@@ -800,14 +834,6 @@ function isDirectory(abs: string): boolean {
   }
 }
 
-function realpathOr(p: string): string {
-  try {
-    return realpathSync(p)
-  } catch {
-    return p
-  }
-}
-
 function projectsContaining(
   workspaceRoot: string,
   changedRelPaths: readonly string[],
@@ -823,8 +849,10 @@ function projectsContaining(
   // O(files · path-depth) instead of O(files · projects): independent of the
   // project count, which is what a big --affected diff on a 1000-project repo
   // pays for.
+  // Keyed NFC: macOS git reports paths NFC (core.precomposeunicode) while a
+  // dir discovered by readdir keeps the spelling it was created with.
   const dirToName = new Map<string, string>()
-  for (const p of projects) dirToName.set(p.dir, p.name)
+  for (const p of projects) dirToName.set(p.dir.normalize('NFC'), p.name)
   // A member linked in from elsewhere in the tree (`pkgs/b -> ../ext/b`) is
   // indexed by its link, and git reports its files at their real place
   // (`ext/b/src/a.txt`), which resolved to no project: an edit there
@@ -835,18 +863,18 @@ function projectsContaining(
     const real = realDirs.get(p.dir) ?? p.dir
     const rel = path.relative(realRoot, real)
     if (rel.startsWith('..') || path.isAbsolute(rel)) continue
-    const spelled = path.resolve(workspaceRoot, rel)
-    if (spelled !== p.dir && !dirToName.has(spelled)) dirToName.set(spelled, p.name)
+    const spelled = path.resolve(workspaceRoot, rel).normalize('NFC')
+    if (!dirToName.has(spelled)) dirToName.set(spelled, p.name)
   }
   const owned = new Set<string>()
   for (const rel of changedRelPaths) {
-    let dir = path.resolve(workspaceRoot, rel)
+    let dir = path.resolve(workspaceRoot, rel).normalize('NFC')
     let hit = false
     for (;;) {
       const name = dirToName.get(dir)
       if (name !== undefined) {
         owned.add(name)
-        on?.path(name, relPosix(dir, path.resolve(workspaceRoot, rel)))
+        on?.path(name, relPosix(dir, path.resolve(workspaceRoot, rel).normalize('NFC')))
         hit = true
         break
       }
@@ -865,7 +893,7 @@ function projectsContaining(
     // this, `--affected` after an edit inside selected none of them.
     const abs = path.resolve(workspaceRoot, rel)
     if (isDirectory(abs)) {
-      const prefix = abs + path.sep
+      const prefix = abs.normalize('NFC') + path.sep
       for (const [dir, name] of dirToName) {
         if (!dir.startsWith(prefix)) continue
         owned.add(name)

package/src/workspace/config-cache.ts

@@ -409,6 +409,16 @@ function keySeed(workspaceFingerprint: string): bigint {
 
 const EXPLICIT_EXT = /\.(?:m?[jt]s|cjs|cts)$/
 
+/**
+ * A file's identity as the key folds it. `hashFile` names an executable
+ * `100755:<oid>`, the slow path's `hashBytes` the bare oid; the mode moves
+ * no evaluation, and with it the warm key of an executable config never
+ * met the stored one, so every load read and re-keyed it.
+ */
+function contentIdentity(identity: string): string {
+  return identity.startsWith('100755:') ? identity.slice(7) : identity
+}
+
 /**
  * The canonical directory Bun resolves `file`'s imports from: its REAL
  * path's, so a config linked in from elsewhere imports its neighbours
@@ -482,7 +492,7 @@ export async function configEvalKey(a: ConfigEvalKeyArgs): Promise<ConfigEvalKey
     const identity = a.hashBytes
       ? a.hashBytes(bytes, file)
       : a.hashFile
-        ? await a.hashFile(file)
+        ? contentIdentity(await a.hashFile(file))
         : await hashOf(file, bytes)
     h = xxh3(`${file}\0${identity}`, h)
     closure.push(file)
@@ -542,6 +552,14 @@ export async function configEvalKey(a: ConfigEvalKeyArgs): Promise<ConfigEvalKey
   return { key: h.toString(16).padStart(16, '0'), closure, indexable }
 }
 
+// `hashFile` names a symlink by its target string (git's mode 120000), not
+// the bytes the evaluation read, so no stored key can match a fold of it.
+// Only a linked config with no relative import is indexed at all; with no
+// warm key it joins the round lookup on its slow key instead of paying a
+// single lookup and an index rewrite per load. The identity is from the
+// lstat `hashFiles` already took: no syscall is added.
+const LINK_IDENTITY = '120000:'
+
 /**
  * The warm path: the key for a config whose ordered closure the store
  * remembers, from per-file identities alone — no read, no scan. The fold is
@@ -561,7 +579,10 @@ export async function configEvalKeyFromClosure(a: {
   } catch {
     return null
   }
-  for (let i = 0; i < a.closure.length; i++) h = xxh3(`${a.closure[i]}\0${identities[i]}`, h)
+  if (identities.some((id) => id.startsWith(LINK_IDENTITY))) return null
+  for (let i = 0; i < a.closure.length; i++) {
+    h = xxh3(`${a.closure[i]}\0${contentIdentity(identities[i]!)}`, h)
+  }
   return h.toString(16).padStart(16, '0')
 }
 
@@ -574,8 +595,8 @@ export function configEvalKeyFromIdentities(a: {
   let h = keySeed(a.workspaceFingerprint)
   for (const file of a.closure) {
     const id = a.identities.get(file)
-    if (id === undefined) return null
-    h = xxh3(`${file}\0${id}`, h)
+    if (id === undefined || id.startsWith(LINK_IDENTITY)) return null
+    h = xxh3(`${file}\0${contentIdentity(id)}`, h)
   }
   return h.toString(16).padStart(16, '0')
 }

package/src/workspace/config-eval.ts

@@ -292,7 +292,11 @@ function acquireWorker(): Worker {
     // config reports the same text it would from an in-process import.
     const err = new Error(msg.message) as Error & { position?: WorkerReply['position'] }
     err.name = msg.name
+    // A stackless throw stays stackless: the rebuilt Error's own stack names
+    // this file, and `configLoadError` reads a stack naming no file as Bun's
+    // JSON loader's.
     if (msg.stack !== null) err.stack = msg.stack
+    else delete err.stack
     if (msg.position !== null) err.position = msg.position
     p.reject(err)
   }

package/src/workspace/config-imports.ts

@@ -281,7 +281,7 @@ function tsconfigTarget(spec: string, fromDir: string, memo?: TsconfigMemo): str
 }
 
 /** A path as Bun names it: realpath'd when it exists. */
-function realpathOr(file: string): string {
+export function realpathOr(file: string): string {
   try {
     return realpathSync(file)
   } catch {
@@ -305,7 +305,7 @@ function selfReference(pkg: string, fromDir: string): boolean {
     const manifest = path.join(dir, 'package.json')
     if (existsSync(manifest)) {
       try {
-        const json = JSON.parse(readFileSync(manifest, 'utf8')) as {
+        const json = JSON.parse(readFileSync(manifest, 'utf8').replace(/^\uFEFF/, '')) as {
           name?: unknown
           exports?: unknown
         }

package/src/workspace/config-schema.ts

@@ -28,6 +28,7 @@ import {
   asTrees,
   isLiteralPattern,
 } from '../util/index.js'
+import { compileNameGlob, parseFilter } from './filter.js'
 import { nonJsonMessage, nonJsonPaths } from './json-data.js'
 
 // Mirrors `WorkspaceConfig` in src/config.ts. Unknown keys are REJECTED for
@@ -77,6 +78,7 @@ const RETENTION_FIELDS = new Set(['olderThan', 'maxSize'])
 
 function validateRetention(retention: unknown, configPath: string): void {
   const where = `${configPath}: \`cacheRetention\``
+  const field = (key: string) => `${configPath}: \`cacheRetention.${key}\``
   if (retention === null || typeof retention !== 'object' || Array.isArray(retention)) {
     throw new UserError(`${where} must be { olderThan?: '30d', maxSize?: '10G' }`)
   }
@@ -90,23 +92,27 @@ function validateRetention(retention: unknown, configPath: string): void {
     olderThan !== undefined &&
     (typeof olderThan !== 'string' || parseDuration(olderThan) === null)
   ) {
-    throw new UserError(`${where}.olderThan must be a duration like '30d', '12h', '90m' or '45s'`)
+    throw new UserError(
+      `${field('olderThan')} must be a duration like '30d', '12h', '90m' or '45s' (got ${JSON.stringify(olderThan)})`,
+    )
   }
   if (maxSize !== undefined && (typeof maxSize !== 'string' || parseSize(maxSize) === null)) {
-    throw new UserError(`${where}.maxSize must be a size like '10G', '500MB' or '64KB'`)
+    throw new UserError(
+      `${field('maxSize')} must be a size like '10G', '500MB' or '64KB' (got ${JSON.stringify(maxSize)})`,
+    )
   }
   // The bounds `vx cache prune` refuses, for the same reason: each evicts
   // every entry, and here it would do so at the end of every run, the
   // entries that run just saved included, so nothing ever hits (item 969).
   if (olderThan !== undefined && parseDuration(olderThan) === 0) {
-    throw new UserError(`${where}.olderThan of 0 evicts every entry after every run`)
+    throw new UserError(`${field('olderThan')} of 0 evicts every entry after every run`)
   }
   if (maxSize !== undefined && parseSize(maxSize) === 0) {
-    throw new UserError(`${where}.maxSize of 0 evicts every entry after every run`)
+    throw new UserError(`${field('maxSize')} of 0 evicts every entry after every run`)
   }
   if (maxSize !== undefined && /^\d+$/.test(maxSize)) {
     throw new UserError(
-      `${where}.maxSize '${maxSize}' reads as ${maxSize} bytes — give a unit (e.g. '${maxSize}M', '${maxSize}G')`,
+      `${field('maxSize')} '${maxSize}' reads as ${maxSize} bytes — give a unit (e.g. '${maxSize}M', '${maxSize}G')`,
     )
   }
 }
@@ -229,6 +235,12 @@ export function validateWorkspace(config: WorkspaceConfig, configPath: string):
         if (plug.commands === null || typeof plug.commands !== 'object') {
           throw new UserError(`${configPath}: \`plugins[${i}].commands\` must be an object`)
         }
+        // A list of commands loaded as the verbs `0`, `1`, … that help listed.
+        if (Array.isArray(plug.commands)) {
+          throw new UserError(
+            `${configPath}: \`plugins[${i}].commands\` must be an object keyed by verb, not an array`,
+          )
+        }
         for (const [verb, cmd] of Object.entries(plug.commands as Record<string, unknown>)) {
           const c = cmd as { description?: unknown; run?: unknown } | null
           if (
@@ -344,6 +356,15 @@ export function validateProjectConfig(config: ProjectConfig, configPath: string)
   ) {
     throw new UserError(`${configPath}: \`tags\` must be an array of non-empty strings`)
   }
+  for (const tag of (tags ?? []) as string[]) {
+    const why = tagProblem(tag)
+    if (why !== null) {
+      throw new UserError(
+        `${configPath}: tag ${JSON.stringify(tag)} ${why} — \`--filter tag:<name>\` could not ` +
+          `name it. Rename the tag.`,
+      )
+    }
+  }
   const tasks = config.tasks
   if (tasks === undefined) return
   if (typeof tasks !== 'object' || tasks === null || Array.isArray(tasks)) {
@@ -1286,7 +1307,7 @@ function assertFilterNamesDeclaredDeps(
 ): void {
   const declared = (dependsOn ?? []).map(specForm)
   const matches = (pattern: string, name: string): boolean =>
-    pattern.includes('*') ? taskPatternRegExp(pattern).test(name) : pattern === name
+    pattern.includes('*') ? compileNameGlob(pattern).test(name) : pattern === name
   const named = (f: SpecForm): boolean =>
     declared.some((d) => {
       if (!matches(d.task, f.task)) return false
@@ -1366,10 +1387,20 @@ export function taskNameProblem(name: string): string | null {
             : null
 }
 
-/** The graph's `*`-only task glob (`compileTaskPattern`), mirrored: `*` is the sole metacharacter. */
-function taskPatternRegExp(pattern: string): RegExp {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')
-  return new RegExp(`^${escaped}$`)
+/**
+ * Why `--filter tag:<tag>` cannot name `tag`, or null. Asked of the filter
+ * parser itself, so a suffix it learns to read is refused here too: `v1...`
+ * read as a dependency walk from `v1`, `v[2]` as `v` changed since ref `2`.
+ */
+function tagProblem(tag: string): string | null {
+  if (tag.trim() !== tag) return 'has surrounding whitespace'
+  if (tag.includes('*')) return "holds '*', which makes it a pattern"
+  const f = parseFilter(`tag:${tag}`, '/')
+  if (f.gitSince !== undefined) {
+    return `ends in "[${f.gitSince}]", which a filter reads as a git range`
+  }
+  if (f.withDeps || f.onlyDeps) return "ends in '...', which a filter reads as a dependency walk"
+  return null
 }
 
 /**
@@ -1493,6 +1524,12 @@ function assertStringArray(v: unknown, where: string): void {
   if (!Array.isArray(v) || v.some((s) => typeof s !== 'string' || s.length === 0)) {
     throw new UserError(`${where} must be an array of non-empty strings`)
   }
+  // No path, host or name holds a NUL; a write grant with one reached the
+  // placeholder create as an internal error.
+  const nul = (v as string[]).find((s) => s.includes('\0'))
+  if (nul !== undefined) {
+    throw new UserError(`${where}: ${JSON.stringify(nul)} holds a NUL byte`)
+  }
 }
 
 /**

package/src/workspace/filter.ts

@@ -20,7 +20,7 @@
 // given, the base set is "all projects" and excluded packages are removed.
 
 import path from 'node:path'
-import { BUN_GLOB_WILDCARDS, UserError } from '../util/index.js'
+import { BUN_GLOB_WILDCARDS, relPosix, UserError } from '../util/index.js'
 import type { PackageGraph } from './package-graph.js'
 import type { ProjectMeta } from './workspace.js'
 
@@ -180,7 +180,7 @@ export function parseFilter(raw: string, workspaceRoot: string): ParsedFilter {
     // against the workspace root like the literal form.
     // A member glob, not a task glob: `Bun.Glob`'s alphabet, the class included.
     if (BUN_GLOB_WILDCARDS.test(pathForm)) {
-      const rel = path.relative(workspaceRoot, matcher).split(path.sep).join('/')
+      const rel = relPosix(workspaceRoot, matcher)
       const glob = rel.replace(/\/+$/, '')
       pathGlob = new Bun.Glob(glob)
       if (glob.endsWith('/**')) pathGlobBase = new Bun.Glob(glob.slice(0, -3))
@@ -293,9 +293,10 @@ function matchSelector(
  * Compile a name pattern where `*` is the sole metacharacter and means "any
  * characters" — pnpm's rule. A path glob would treat `/` as a separator, so
  * `*` could never cross the `@scope/` boundary: `--filter '*'` would select
- * only UNSCOPED packages, and `*core*` would match nothing at all.
+ * only UNSCOPED packages, and `*core*` would match nothing at all. Task
+ * patterns share it: it mirrors the graph's `compileTaskPattern`.
  */
-function compileNameGlob(pattern: string): RegExp {
+export function compileNameGlob(pattern: string): RegExp {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')
   return new RegExp(`^${escaped}$`)
 }