@vzn/vx 0.0.646 → 0.0.649

package/src/report/terminal-signals.ts

@@ -12,6 +12,7 @@ export interface TerminalSignals {
 export function terminalSignals(
   env: Readonly<Record<string, string | undefined>>,
 ): TerminalSignals {
+  if (inMultiplexer(env)) return { progress: false, notify: false }
   const program = env['TERM_PROGRAM']
   if (program === 'ghostty') return { progress: true, notify: true }
   // iTerm2 posts OSC 9 since 3.0 and draws OSC 9;4 since 3.6.
@@ -24,6 +25,17 @@ export function terminalSignals(
   return { progress: false, notify: false }
 }
 
+/** Inside tmux or screen, which keep the outer terminal's variables (`WT_SESSION`, its `TERM_PROGRAM`). */
+function inMultiplexer(env: Readonly<Record<string, string | undefined>>): boolean {
+  const program = env['TERM_PROGRAM']
+  return (
+    env['TMUX'] !== undefined ||
+    env['STY'] !== undefined ||
+    program === 'tmux' ||
+    program === 'screen'
+  )
+}
+
 function atLeast(version: string | undefined, major: number, minor: number): boolean {
   const m = /^(\d+)\.(\d+)/.exec(version ?? '')
   if (m === null) return false
@@ -50,9 +62,8 @@ export function notifyEscape(text: string): string {
  * tmux and screen pass it through only when configured to.
  */
 export function terminalLinks(env: Readonly<Record<string, string | undefined>>): boolean {
-  if (env['TMUX'] !== undefined || env['STY'] !== undefined) return false
+  if (inMultiplexer(env)) return false
   const program = env['TERM_PROGRAM']
-  if (program === 'tmux' || program === 'screen') return false
   if (program === 'ghostty' || program === 'WezTerm' || program === 'vscode') return true
   if (program === 'iTerm.app') return atLeast(env['TERM_PROGRAM_VERSION'], 3, 1)
   if (env['WT_SESSION'] !== undefined || env['KITTY_WINDOW_ID'] !== undefined) return true

package/src/settings.ts

@@ -15,8 +15,7 @@ import {
 export type SettingKind =
   | { readonly type: 'int'; readonly min: number }
   | { readonly type: 'concurrency' }
-  // `zero`: 0 is a value ("wait for nothing not already done"), not a typo.
-  | { readonly type: 'duration'; readonly timer?: true; readonly zero?: true }
+  | { readonly type: 'duration'; readonly timer?: true }
   // `off`: `false` is a value, 0 bytes (the thing the size bounds is off).
   | { readonly type: 'size'; readonly off?: true }
   | { readonly type: 'bool' }
@@ -48,7 +47,7 @@ export const SETTINGS: readonly Setting[] = [
     path: 'baseBranch',
     kind: { type: 'string' },
     default: "origin/HEAD's branch, then main, then master",
-    doc: 'The default branch: a run on it has no cache scope and a bare `--affected` no base; elsewhere both use the merge base with `origin/<baseBranch>`.',
+    doc: 'The default branch: a run on it has no cache scope and a bare `--affected` no base; elsewhere both use the merge base with `origin/<baseBranch>`. Named alone: `main`, not `origin/main`.',
   },
   {
     path: 'affectedBase',
@@ -323,7 +322,7 @@ export function parseSettingValue(kind: SettingKind, raw: unknown): unknown {
       return parseConcurrency(typeof raw === 'number' ? String(raw) : raw)
     case 'duration': {
       const n = typeof raw === 'string' ? parseDuration(raw) : null
-      if (n === null || (n === 0 && kind.zero !== true)) return null
+      if (n === null || n === 0) return null
       return kind.timer === true && n > MAX_TIMEOUT_MS ? null : n
     }
     case 'size':
@@ -359,10 +358,12 @@ export function settingRefusal(
         : typeof raw === 'string' && /^\d+$/.test(raw)
           ? Number(raw)
           : null
-    if (n !== null && Number.isSafeInteger(n) && n > 0) {
+    const bare = n !== null && Number.isSafeInteger(n) && n > 0
+    // A bare number past the ceiling is past it in either unit it could mean.
+    const ms = bare ? n : typeof raw === 'string' ? parseDuration(raw) : null
+    if (bare && !(kind.timer === true && n > MAX_TIMEOUT_MS)) {
       return `${where} takes a duration with its unit, like '${n}ms' or '${Math.max(1, Math.round(n / 1000))}s' (got ${got})`
     }
-    const ms = typeof raw === 'string' ? parseDuration(raw) : null
     if (kind.timer === true && ms !== null && ms > MAX_TIMEOUT_MS) {
       return (
         `${where} of ${got} exceeds the maximum timer delay (${MAX_TIMEOUT_MS} ms, ~24.8 days): ` +

package/src/util/bun-version.ts

@@ -20,8 +20,11 @@
  * refusing would be heavier than the measurement supports. What the
  * measurement supports is that a green exit can hide a truncated answer, and
  * that is what the warning says.
+ *
+ * 1.4.4: vx expands a brace range (`{1..3}`) as `Bun.Glob` does from 1.4.4
+ * on; an older `Bun.Glob` reads it as text, so a scan and a match disagree.
  */
-export const MIN_BUN = [1, 4, 0] as const
+export const MIN_BUN = [1, 4, 4] as const
 
 /** True when `version` is older than {@link MIN_BUN}. */
 export function isUnsupportedBun(version: string): boolean {

package/src/util/colors.ts

@@ -96,7 +96,9 @@ export function paint(
   colors: ColorSupport,
   opts: PaintOptions = {},
 ): string {
-  if (!colors.enabled) return text
+  // Empty text paints nothing: an escape pair around no text is bytes and no
+  // mark (a full bar's empty remainder).
+  if (!colors.enabled || text === '') return text
   let prefix = ''
   if (opts.bold) prefix += BOLD
   if (opts.dim) prefix += DIM
@@ -107,7 +109,7 @@ export function paint(
 
 /**
  * Identity hues for the two halves of a `project#task` id, never a status
- * colour: one name, one hue, in every run, list and row (M, 2026-10-15:
+ * colour: one name, one hue, in every run, list and row (2026-10-15:
  * every `#build` matches every other `#build`).
  */
 const IDENTITY_PALETTE = [

package/src/util/config-frame.ts

@@ -18,7 +18,7 @@ const HEAD = /^(\/[^\n]*?\/(?:vx\.config|\.vx\/workspace)\.[cm]?[jt]s)(?:: (task
  */
 export function configErrorFrame(message: string, cwd: string): string | undefined {
   const head = HEAD.exec(message)
-  if (head === null) return undefined
+  if (head === null) return positionFrame(message, cwd)
   const [, file, fieldPath, colon] = head as unknown as [string, string, string?, string?]
   const rest = message.slice(head[0].length)
   // The field the refusal is about, past the path that leads to it:
@@ -35,6 +35,37 @@ export function configErrorFrame(message: string, cwd: string): string | undefin
   }
   const at = locate(source, segments)
   if (at === undefined) return undefined
+  return framed(file, source, at, message.slice(file.length), cwd)
+}
+
+// The loader's `Project config <file>:<line>:<col>: …`: a syntax error,
+// placed by Bun, in the config itself.
+const POSITION =
+  /^(?:Project|Workspace) config (\/[^\n]*?\/(?:vx\.config|\.vx\/workspace)\.[cm]?[jt]s):(\d+):(\d+)(: [^]*)$/
+
+function positionFrame(message: string, cwd: string): string | undefined {
+  const pos = POSITION.exec(message)
+  if (pos === null) return undefined
+  const [, file, line, col, rest] = pos as unknown as [string, string, string, string, string]
+  let source: string
+  try {
+    source = readFileSync(file, 'utf8')
+  } catch {
+    return undefined
+  }
+  const at = { line: Number(line), col: Math.max(1, Number(col)) }
+  if (at.line < 1 || at.line > source.split('\n').length) return undefined
+  return framed(file, source, at, rest, cwd)
+}
+
+/** `<file>:<line>:<col><rest>` relative to `cwd`, over the source lines up to `at`. */
+function framed(
+  file: string,
+  source: string,
+  at: { line: number; col: number },
+  rest: string,
+  cwd: string,
+): string {
   const lines = source.split('\n')
   // Relative to where the user stands, unless that means climbing out.
   const rel = path.relative(cwd, file)
@@ -50,7 +81,7 @@ export function configErrorFrame(message: string, cwd: string): string | undefin
     .replace(/\t/g, '  ')
     .replace(/\S/g, ' ')
   frame.push(`  ${' '.repeat(width)} | ${lead}^`)
-  return `${shown}:${at.line}:${at.col}${message.slice(file.length)}\n\n${frame.join('\n')}`
+  return `${shown}:${at.line}:${at.col}${rest}\n\n${frame.join('\n')}`
 }
 
 /**
@@ -106,14 +137,20 @@ export function configRefusal(message: string, cwd: string): ConfigRefusal | und
   const cut = framed.indexOf('\n\n')
   const line = framed.slice(0, cut)
   const frame = framed.slice(cut + 2)
-  const at = /^(\S+?:\d+:\d+):? (.*)$/s.exec(line)
+  // A path may hold spaces (`packages/my app/`); the first `:line:col` ends it.
+  const at = /^([^\n]+?:\d+:\d+):? (.*)$/s.exec(line)
   if (at === null) return { where: line, problem: '', frame }
-  const said = /^(.*?)(?: \(allowed: ([^)]*)\))?(?: — did you mean ([^?]+)\?)?$/s.exec(at[2]!)!
+  // After ` — `: the field meant, or how vx spells another runner's field.
+  const said =
+    /^(.*?)(?: \(allowed: ([^)]*)\))?(?: — (?:did you mean ([^?]+)\?|vx spells it (.+)))?$/s.exec(
+      at[2]!,
+    )!
   return {
     where: at[1]!,
     problem: said[1]!.replace(/^has /, ''),
     ...(said[2] !== undefined ? { allowed: said[2] } : {}),
     ...(said[3] !== undefined ? { fix: `use ${said[3]}` } : {}),
+    ...(said[4] !== undefined ? { fix: `use ${said[4]}` } : {}),
     frame,
   }
 }

package/src/{graph → util}/dependency-spec.ts

@@ -1,6 +1,8 @@
 // Parser for the Turbo/Nx-style task-edge micro-syntax used in
 // `dependsOn` and `inputs.tasks`. Returns a small discriminated
-// union the graph builder + cache filter both consume.
+// union the graph builder + cache filter both consume. In util, not
+// graph: the schema parses `inputs.tasks` at load (`vx lock`), and the
+// workspace module cannot import the graph.
 
 export type DependencySpec =
   | { kind: 'self'; task: string; negated: boolean }
@@ -9,9 +11,12 @@ export type DependencySpec =
   | { kind: 'wildcardSelf'; negated: boolean }
   | { kind: 'wildcardDeps'; negated: boolean }
 
+/** The field an entry came from, which the error names. */
+type SpecField = 'dependsOn' | 'inputs.tasks'
+
 export class DependencySpecError extends Error {
-  constructor(raw: string, message: string) {
-    super(`invalid dependsOn "${raw}": ${message}`)
+  constructor(field: SpecField, raw: string, message: string) {
+    super(`invalid ${field} "${raw}": ${message}`)
   }
 }
 
@@ -31,49 +36,53 @@ export function compileTaskPattern(pattern: string): RegExp {
   return new RegExp(`^${escaped}$`)
 }
 
+// `*` is the matcher's only metacharacter, so a run of them (`**`) matches
+// every name: the bare wildcard, not a pattern that names a namespace.
+const ALL_STARS = /^\*+$/
+
 /**
  * Parse one `dependsOn` / `inputs.tasks` entry.
  *
  *   `name`       → self.name
  *   `^name`      → every dep workspace's `name` task
  *   `pkg#name`   → specific package's `name` task (cross-edge)
- *   `*`          → all same-project upstream (filter-only)
- *   `^*`         → all dep upstream (filter-only)
+ *   `*`          → all same-project upstream (filter-only; `**` too)
+ *   `^*`         → all dep upstream (filter-only; `^**` too)
  *   `!<form>`    → negation of any of the above (filter-only)
  *
  * Wildcards and negation are accepted everywhere — callers (the graph
  * builder vs the filter) decide which ones make semantic sense and
  * surface their own validation errors. This keeps the parser pure.
  */
-export function parseDependencySpec(raw: string): DependencySpec {
-  if (raw.length === 0) throw new DependencySpecError(raw, 'empty spec')
+export function parseDependencySpec(raw: string, field: SpecField): DependencySpec {
+  if (raw.length === 0) throw new DependencySpecError(field, raw, 'empty spec')
 
   let negated = false
   let s = raw
   if (s.startsWith('!')) {
     negated = true
     s = s.slice(1)
-    if (s.length === 0) throw new DependencySpecError(raw, 'negation with no body')
+    if (s.length === 0) throw new DependencySpecError(field, raw, 'negation with no body')
   }
 
   if (s.startsWith('^')) {
     const rest = s.slice(1)
-    if (rest.length === 0) throw new DependencySpecError(raw, '"^" with no task name')
-    if (rest === '*') return { kind: 'wildcardDeps', negated }
+    if (rest.length === 0) throw new DependencySpecError(field, raw, '"^" with no task name')
+    if (ALL_STARS.test(rest)) return { kind: 'wildcardDeps', negated }
     if (rest.includes('#')) {
-      throw new DependencySpecError(raw, '"^" cannot combine with "pkg#task" — pick one')
+      throw new DependencySpecError(field, raw, '"^" cannot combine with "pkg#task" — pick one')
     }
     return { kind: 'deps', task: rest, negated }
   }
 
-  if (s === '*') return { kind: 'wildcardSelf', negated }
+  if (ALL_STARS.test(s)) return { kind: 'wildcardSelf', negated }
 
   const hashIdx = s.indexOf('#')
   if (hashIdx >= 0) {
     const project = s.slice(0, hashIdx)
     const task = s.slice(hashIdx + 1)
     if (!project || !task) {
-      throw new DependencySpecError(raw, 'pkg#task requires a non-empty project AND task')
+      throw new DependencySpecError(field, raw, 'pkg#task requires a non-empty project AND task')
     }
     return { kind: 'cross', project, task, negated }
   }

package/src/util/edit-distance.ts

@@ -23,7 +23,8 @@ export function editDistance(a: string, b: string, cap = 3): number {
 
 /**
  * The ONE near-miss rule every "did you mean" hint applies: the closest
- * candidate within two edits of `name`, or undefined — an exact match is
+ * candidate within two edits of `name` (for a name of four letters or
+ * fewer, one or a swap of two), or undefined — an exact match is
  * not a hint, and anything further would guess rather than help. Task
  * names, `pkg#task` halves, project names, flags and verbs all go through
  * here so a typo is hinted the same way wherever it is typed.
@@ -33,6 +34,9 @@ export function nearest(
   candidates: Iterable<string>,
   maxEdits = 2,
 ): string | undefined {
+  // Two edits rewrite half of a word of four letters or fewer (`--poll`
+  // read as `--all`, `vx test` as `last`), unless they swap two letters.
+  const short = maxEdits === 2 && name.replace(/^-+/, '').length <= 4
   let best: string | undefined
   let bestD = maxEdits + 1
   for (const c of candidates) {
@@ -40,6 +44,10 @@ export function nearest(
     // `--continue-on-error` was nine edits from `--concurrency`, capped to
     // the three `vx run`'s same-prefix hint allows, and offered.
     const d = editDistance(name, c, maxEdits + 1)
+    // Edits that rewrite the whole of both leave nothing in common:
+    // `--filter=x9` offered the root, `//`.
+    if (d >= Math.max(name.length, c.length)) continue
+    if (short && d === 2 && !sameLetters(name, c)) continue
     if (d < bestD) {
       bestD = d
       best = c
@@ -48,6 +56,10 @@ export function nearest(
   return best === name ? undefined : best
 }
 
+function sameLetters(a: string, b: string): boolean {
+  return a.length === b.length && a.split('').sort().join('') === b.split('').sort().join('')
+}
+
 /**
  * Up to `limit` candidates worth offering for `name`: the nearest by edit
  * distance first, then any that contain it (or that it contains), case-

package/src/util/env-flag.ts

@@ -0,0 +1,9 @@
+/**
+ * Whether a flag-like variable (`CI`, `GITHUB_ACTIONS`) is on: set, and not
+ * `''`, `0` or `false` in any case. Several vendors set `CI=true`, and a
+ * PowerShell `$false` writes `False`; each reader of CI asks this one, so a
+ * run cannot be CI to one part of vx and a laptop to another.
+ */
+export function envFlagOn(v: string | undefined): boolean {
+  return v !== undefined && v !== '' && v !== '0' && v.toLowerCase() !== 'false'
+}

package/src/util/errors.ts

@@ -57,8 +57,12 @@ export function refusal(
 }
 
 // A refusal that opens with the config that caused it: the schema's
-// `<file>: tasks.<name> …` and the loader's `<file> has unknown field …`.
-const CONFIG_REFUSAL = /^\/\S*\/(?:vx\.config|\.vx\/workspace)\.[cm]?[jt]s\b/
+// `<file>: tasks.<name> …`, the loader's `<file> has unknown field …`, and
+// its `Project config <file>: …` and `Workspace config at <file> …` (a load
+// that failed: a syntax error, a missing import, no default object), which
+// answered VX_E_REFUSED.
+const CONFIG_REFUSAL =
+  /^(?:(?:Project|Workspace) config (?:at )?)?\/\S*\/(?:vx\.config|\.vx\/workspace)\.[cm]?[jt]s\b/
 
 /**
  * The stable code of anything `bin.ts` catches. A UserError's own, but
@@ -106,6 +110,30 @@ export function errorDocument(code: string, message: string): string {
   return `${JSON.stringify({ ok: false, error: { code, message, ...docs } })}\n`
 }
 
+/**
+ * What a thrown value says, for a line that names its thrower. A plugin
+ * may throw anything: `String(err)` read `[object Object]` for an
+ * error-like `{ message }`, `undefined` for a bare `throw`, and itself threw
+ * on an object with no prototype. Never throws.
+ */
+export function thrownMessage(err: unknown): string {
+  try {
+    if (typeof err === 'string') return err === '' ? 'threw an empty string' : err
+    if (typeof err === 'object' && err !== null) {
+      const message = (err as { message?: unknown }).message
+      if (typeof message === 'string' && message !== '') return message
+      if (err instanceof Error) return `threw ${err.name} with no message`
+      const json = JSON.stringify(err)
+      if (json !== undefined) return `threw ${json.length > 200 ? `${json.slice(0, 200)}…` : json}`
+      return 'threw an object'
+    }
+    if (typeof err === 'bigint') return `threw ${err}n`
+    return `threw ${String(err)}`
+  } catch {
+    return 'threw an object'
+  }
+}
+
 /**
  * `instanceof UserError`, plus the same class arriving from ANOTHER COPY of
  * core. A compiled `vx` binary carries core inside it while a plugin in the
@@ -164,9 +192,21 @@ export function isFsRefusal(err: unknown): err is NodeJS.ErrnoException {
 
 export const DISK_FULL_HINT = 'the disk that path is on is full'
 
+/** What follows the path when the refused call only reads. */
+const READ_PERMISSION_HINT = 'a path vx must read is not readable by this user'
+
+/**
+ * Calls that only read. `open` is either, so it keeps the write hint: the
+ * reads vx opens name their own refusal (`hashFileFromDisk`).
+ */
+const READ_SYSCALLS = new Set(['scandir', 'stat', 'lstat', 'readlink', 'read', 'realpath'])
+
 /** The one-line hint after a refusal's path. */
 export function fsRefusalHint(err: NodeJS.ErrnoException): string {
-  return isDiskFull(err) ? DISK_FULL_HINT : PERMISSION_HINT
+  const { syscall } = err
+  if (isDiskFull(err)) return DISK_FULL_HINT
+  // A listing told to be a write sent the user to chmod the wrong thing.
+  return READ_SYSCALLS.has(syscall ?? '') ? READ_PERMISSION_HINT : PERMISSION_HINT
 }
 
 /**
@@ -188,6 +228,7 @@ export function isExecutableMissing(err: unknown): boolean {
 export function gitSpawnRefusal(cwd: string): UserError {
   return new UserError(
     `vx requires git: failed to spawn 'git' (working dir: ${cwd}). Install git and re-run.`,
+    'VX_E_NO_GIT',
   )
 }
 
@@ -200,6 +241,21 @@ export function notAWorkTree(cwd: string, stderr = ''): UserError {
   return new UserError(
     `vx requires git: ${cwd} is not inside a git work tree. ` +
       `Run 'git init' in your workspace root.${stderr ? ` (git: ${stderr})` : ''}`,
+    'VX_E_NO_GIT',
+  )
+}
+
+/**
+ * A git that ran in `cwd` and failed: no repository there is
+ * `notAWorkTree`, anything else (a corrupt index, a missing object) is git's
+ * own failure, `VX_E_GIT`. Every failed `ls-files` read as "not a work
+ * tree", telling a user with a broken index to `git init` (2026-10-28).
+ */
+export function gitFailure(cwd: string, args: string, exitCode: number, stderr: string): UserError {
+  if (/not a git repository/i.test(stderr)) return notAWorkTree(cwd, stderr)
+  return new UserError(
+    `git ${args} failed (exit ${exitCode}) in ${cwd}: ${stderr || 'no output'}. Run it there to see why.`,
+    'VX_E_GIT',
   )
 }
 

package/src/util/essential-env.ts

@@ -1,3 +1,6 @@
+import { existsSync, realpathSync } from 'node:fs'
+import path from 'node:path'
+
 /**
  * Every task gets these (`exec/env.ts`), so `hideEnvFromTasks` leaves
  * them. Exported so the schema doc's enumeration of it can be PINNED against the
@@ -28,4 +31,58 @@ export const ESSENTIAL_ENV: readonly string[] = [
   // manager (offline or sandboxed: fails) and pnpm loses its global dir.
   'COREPACK_HOME',
   'PNPM_HOME',
+  // The XDG base directories, machine paths as HOME is. Stripped, a task
+  // resolved other homes than the shell did: pnpm used another store, and
+  // a CLI keeping its login there ran signed out (vercel/turborepo#13145).
+  'XDG_CONFIG_HOME',
+  'XDG_DATA_HOME',
+  'XDG_CACHE_HOME',
+  'XDG_STATE_HOME',
+  'XDG_RUNTIME_DIR',
 ]
+
+/**
+ * `PATH` less each `node_modules/.bin` inside `workspaceRoot`. `npm run`
+ * in a member puts that member's bins, its parents' and the root's on the
+ * PATH vx inherits; a task that kept them ran a sibling's bin, which no
+ * key sees. A task gets back the two it may see (`taskBinDirs`). Inside
+ * by spelling, or by canonical path: an entry spelled through a symlink
+ * (macOS's `/tmp`, a linked home, a shell's `$PWD`) kept a sibling's bin
+ * beside a canonical root.
+ */
+export function withoutWorkspaceBins(PATH: string, workspaceRoot: string): string {
+  const bin = `${path.sep}node_modules${path.sep}.bin`
+  const within = (dir: string, root: string): boolean =>
+    dir.startsWith(root.endsWith(path.sep) ? root : root + path.sep)
+  let root: string | undefined
+  return PATH.split(path.delimiter)
+    .filter((entry) => {
+      const dir = entry.endsWith(path.sep) ? entry.slice(0, -1) : entry
+      if (!dir.endsWith(bin)) return true
+      if (within(dir, workspaceRoot)) return false
+      // Relative, it is the task's cwd's: not a place this check can name.
+      if (!path.isAbsolute(dir)) return true
+      const real = canonical(dir)
+      if (real === undefined) return true
+      root ??= canonical(workspaceRoot) ?? workspaceRoot
+      return !within(real, root)
+    })
+    .join(path.delimiter)
+}
+
+/**
+ * `p`'s canonical spelling; undefined when it is not there, and a missing
+ * directory on PATH resolves nothing. Asked per call, never memoized: a
+ * task may create the bin directory (an install) or a link above it, and a
+ * fact about a file a task can write is not reused across tasks.
+ */
+function canonical(p: string): string | undefined {
+  // A stat, not a throw: most such entries are npm's ancestors of the
+  // root, and an ENOENT thrown per entry was 3 µs a spawn each.
+  if (!existsSync(p)) return undefined
+  try {
+    return realpathSync.native(p)
+  } catch {
+    return undefined
+  }
+}

package/src/util/git-ignored.ts

@@ -1,4 +1,4 @@
-// Whether git ignores everything an output glob can write (M, 2026-10-15):
+// Whether git ignores everything an output glob can write (2026-10-15):
 // a key reads only what git lists, so such an output never reaches a
 // reader's key. Asked of git, never read from a `.gitignore`: git alone
 // knows every rule source (nested files, `info/exclude`, `core.excludesFile`)

package/src/util/hash.ts

@@ -32,3 +32,38 @@ export function xxh3(input: string | Uint8Array, seed: bigint = 0n): bigint {
 export function xxh3hex(input: string | Uint8Array, seed: bigint = 0n): string {
   return xxh3(input, seed).toString(16).padStart(16, '0')
 }
+/**
+ * `v` with every object's keys sorted, all the way down: `v` itself when
+ * they are already, a copy when not. A key hashes a config's JSON, and the
+ * order a file or a plugin spells its keys in says nothing. Checked first,
+ * a config the lock wrote sorted costs a walk, not a copy.
+ */
+export function keysSorted<T>(v: T): T {
+  return isSorted(v) ? v : (sortedDeep(v) as T)
+}
+
+function isSorted(v: unknown): boolean {
+  if (v === null || typeof v !== 'object') return true
+  if (Array.isArray(v)) return v.every(isSorted)
+  let prev: string | undefined
+  for (const k in v) {
+    if (prev !== undefined && prev > k) return false
+    prev = k
+    if (!isSorted((v as Record<string, unknown>)[k])) return false
+  }
+  return true
+}
+
+function sortedDeep(v: unknown): unknown {
+  if (v === null || typeof v !== 'object') return v
+  if (Array.isArray(v)) return v.map(sortedDeep)
+  const out: Record<string, unknown> = {}
+  for (const k of Object.keys(v).sort()) {
+    const value = sortedDeep((v as Record<string, unknown>)[k])
+    // Assigned, `__proto__` sets the copy's prototype and leaves the JSON.
+    if (k === '__proto__')
+      Object.defineProperty(out, k, { value, enumerable: true, writable: true, configurable: true })
+    else out[k] = value
+  }
+  return out
+}

package/src/util/hide-env.ts

@@ -1,3 +1,5 @@
+import { readFileSync, realpathSync } from 'node:fs'
+import path from 'node:path'
 import { ESSENTIAL_ENV } from './essential-env.js'
 
 const PR_SET_DUMPABLE = 4
@@ -5,8 +7,8 @@ const PR_SET_DUMPABLE = 4
 /**
  * Hide vx's environment from a same-user task. A task gets only declared
  * variables, but vx itself holds the rest. Not a boundary (`exec.sandbox`
- * is): it hides the environment, not files. On every verb (owner,
- * 2026-10-13).
+ * is): it hides the environment, not files. On every verb
+ * (2026-10-13).
  *
  * Linux: make vx non-dumpable, so its `/proc/<pid>/environ` (and ptrace)
  * close to the task. A child is dumpable again after `exec`, so tasks are
@@ -16,13 +18,16 @@ const PR_SET_DUMPABLE = 4
  *
  * macOS: `ps eww` reads the env strings the kernel copied above the
  * stack, and no flag closes that to the same user, so vx zeroes the
- * values there (owner, 2026-10-13: "Do the override then on macOS").
+ * values there (2026-10-13: "Do the override then on macOS").
  * Bun copied the env at startup, so `process.env`, and every task built
  * from it, keeps them.
  */
 export async function hideEnvFromTasks(): Promise<boolean> {
   if (process.platform === 'darwin') return wipeStartupEnv()
-  if (process.platform !== 'linux' || process.env['VX_DEBUG_DUMPABLE']) return false
+  // `debug.dumpable` is a bool (util sits below src/settings.ts, so it reads
+  // it itself, as util/timing.ts does): `0` and `false` hide too.
+  const dumpable = process.env['VX_DEBUG_DUMPABLE']
+  if (process.platform !== 'linux' || dumpable === 'true' || dumpable === '1') return false
   try {
     const { dlopen, FFIType } = await import('bun:ffi')
     const libc = dlopen('libc.so.6', {
@@ -97,11 +102,46 @@ export function gitEnv(): Record<string, string> {
     if (
       name.startsWith('GIT_') ||
       name.startsWith('LC_') ||
-      name === 'XDG_CONFIG_HOME' ||
       name === 'LANGUAGE' ||
       ESSENTIAL_ENV.includes(name)
     )
       env[name] = value
   }
+  if (env['GIT_DIR'] !== undefined && env['GIT_WORK_TREE'] === undefined) {
+    if (rediscovers(env['GIT_DIR'])) delete env['GIT_DIR']
+  }
   return env
 }
+
+const rediscovered = new Map<string, boolean>()
+
+/**
+ * Whether a plain `git` where vx started finds the repository `gitDir`
+ * names anyway. A linked worktree's hook exports its gitdir as GIT_DIR and
+ * no GIT_WORK_TREE, and git then takes ITS cwd as the work tree's top: vx
+ * runs git in the workspace root, a subfolder there, and git read every
+ * file as untracked. Without the variable git finds the top itself. A
+ * GIT_DIR naming any other repository (a bare one, dotfiles) is kept.
+ */
+function rediscovers(gitDir: string): boolean {
+  const cwd = process.cwd()
+  const key = `${cwd}\0${gitDir}`
+  let hit = rediscovered.get(key)
+  if (hit === undefined) {
+    hit = false
+    try {
+      const abs = path.resolve(cwd, gitDir)
+      let dotGit = abs
+      // A linked worktree's admin dir names its checkout's `.git` file.
+      try {
+        dotGit = path.resolve(abs, readFileSync(path.join(abs, 'gitdir'), 'utf8').trim())
+      } catch {}
+      if (path.basename(dotGit) === '.git') {
+        const rel = path.relative(realpathSync(path.dirname(dotGit)), realpathSync(cwd))
+        hit = !rel.startsWith('..') && !path.isAbsolute(rel)
+      }
+    } catch {}
+    rediscovered.set(key, hit)
+  }
+  return hit
+}