@vzn/vx 0.0.646 → 0.0.649

package/src/orchestrator/doctor.ts

@@ -19,6 +19,7 @@ import {
   machineMemoryBytes,
   machineParallelism,
   treeBytes,
+  ui,
 } from '../util/index.js'
 import { vxPath } from '../handoff.js'
 import { VERSION } from '../version.js'
@@ -32,10 +33,18 @@ import {
 import { flakyTasks, type FlakyTask } from '../history/index.js'
 import type { VxPlugin } from './plugin.js'
 import { discoverProjects, loadProjects, loadWorkspacePlugins, lockReader } from './projects.js'
-import { atPath, envName, resolveSetting, SETTINGS, type SettingSource } from '../settings.js'
+import {
+  atPath,
+  envName,
+  parseSettingValue,
+  resolveSetting,
+  settingRefusal,
+  SETTINGS,
+  type SettingSource,
+} from '../settings.js'
 
 const warnToStderr = (message: string): void => {
-  process.stderr.write(`${message}\n`)
+  ui.say('warn', message)
 }
 
 /** The doctor's facts, typed: what `--format json` prints and the pretty rows render. */
@@ -89,6 +98,11 @@ export interface InfoFacts {
   schemaVersion: string
   cacheEntries: number
   cacheBytes: number
+  /**
+   * Why the cache index cannot be read (a file SQLite cannot open, and its
+   * fix); null when it reads. While set, the counts it holds read zero.
+   */
+  cacheIndexError: string | null
   /**
    * Every setting (src/settings.ts) as a run with no flags takes it: its
    * variable's value, else the workspace's (after the `config` stage),
@@ -96,7 +110,12 @@ export interface InfoFacts {
    */
   settings: Record<
     string,
-    { value: string | number | boolean | null; source: 'env' | 'workspace' | 'default' }
+    {
+      value: string | number | boolean | null
+      source: 'env' | 'workspace' | 'default'
+      /** Why a run refuses this variable's value; absent when it takes it. */
+      refused?: string
+    }
   >
   orphans: { artifacts: number; bytes: number }
   runs24h: number
@@ -106,6 +125,8 @@ export interface InfoFacts {
   /** Tasks the retained history shows failing on a key that had passed. */
   flakyTasks: FlakyTask[]
   lockfile: boolean
+  /** Why a run refuses the lock that is there; null when it reads it (or there is none). */
+  lockError: string | null
   /**
    * Whether this host can run a task's `exec.sandbox`, and how many loaded
    * tasks declare one. A declared sandbox whose runtime cannot start is a
@@ -127,6 +148,34 @@ export interface CollectInfoOptions {
 }
 
 export async function collectInfo(cwd: string, opts: CollectInfoOptions = {}): Promise<InfoFacts> {
+  // A variable a run refuses is a fact of the report, not a refusal of it:
+  // set aside while the workspace loads, so no deep reader throws on it.
+  const refused = refusedSettings()
+  for (const r of refused.values()) delete process.env[r.name]
+  try {
+    const facts = await collectInfoChecked(cwd, opts)
+    for (const [p, r] of refused)
+      facts.settings[p] = { value: r.raw, source: 'env', refused: r.reason }
+    return facts
+  } finally {
+    for (const r of refused.values()) process.env[r.name] = r.raw
+  }
+}
+
+/** Each set setting variable a run refuses, by path: its name, value and why. */
+function refusedSettings(): Map<string, { name: string; raw: string; reason: string }> {
+  const out = new Map<string, { name: string; raw: string; reason: string }>()
+  for (const s of SETTINGS) {
+    if (s.env === false) continue
+    const name = envName(s.path)
+    const raw = process.env[name]
+    if (raw === undefined || raw === '' || parseSettingValue(s.kind, raw) !== null) continue
+    out.set(s.path, { name, raw, reason: settingRefusal(s.path, name, raw) })
+  }
+  return out
+}
+
+async function collectInfoChecked(cwd: string, opts: CollectInfoOptions): Promise<InfoFacts> {
   const warn = opts.warn ?? warnToStderr
   // Both first: outside a workspace, or under a workspace config that does
   // not load, the doctor refuses at once, with no probe (~180 ms) ahead.
@@ -162,65 +211,90 @@ async function collectWorkspaceInfo(
   // The lock's projects: none without a lock, or with one a run would
   // refuse, which is `vx lock`'s to report.
   const lock = lockReader(root)
+  // A lock a run refuses is said, not swallowed: "projects lock yes" with
+  // no task hid why every run failed (2026-10-28).
+  let refused: string | null = null
   const held = await lock().then(
     () => true,
     (err: unknown) => {
       if (!isUserError(err)) throw err
+      refused = err.message
       return false
     },
   )
   const metas = held ? await discoverProjects(root, lock, plugins, cacheDir, warn) : []
   const storeRoot =
     opts.cacheDir === undefined ? await resolveStoreRoot(root, workspaceConfig) : null
-  const cache = new Cache(cacheDir, undefined, undefined, undefined, 'inspect', storeRoot)
-  let stats
-  let orphans
-  let flaky: FlakyTask[]
+  // The index is read first and alone: one SQLite cannot read is a fact
+  // of the report, with its fix, not a refusal of it — the doctor is where
+  // a broken setup is diagnosed.
+  let stats: ReturnType<Cache['stats']> = {
+    entryCount: 0,
+    totalBytes: 0,
+    runCountLast24h: 0,
+    hitCountLast24h: 0,
+    restoredCountLast24h: 0,
+  }
+  let orphans = { orphans: 0, orphanBytes: 0 }
+  let flaky: FlakyTask[] = []
+  let indexError: string | null = null
+  let indexStore: string | undefined
+  try {
+    const cache = new Cache(cacheDir, undefined, undefined, undefined, 'inspect', storeRoot)
+    try {
+      indexStore = cache.storeDir
+      stats = cache.stats()
+      orphans = await cache.orphanStats()
+      flaky = flakyTasks(cache.dbHandle())
+    } finally {
+      cache.close()
+    }
+  } catch (err) {
+    // An index of another schema is refused as by every reading verb: this
+    // vx reads nothing in it, and the next run resets it.
+    if (!isUserError(err) || err.code === 'VX_E_CACHE_VERSION') throw err
+    indexError = err.message
+  }
   let taskCount = 0
   let sandboxed = 0
+  // The run path's load — the lock, a plugin's `project` stage counted —
+  // so the doctor's task count is the number a run would see. No lock, or
+  // one a run would refuse, counts zero: broken configs are `vx lock`'s
+  // to report.
   try {
-    stats = cache.stats()
-    orphans = await cache.orphanStats()
-    flaky = flakyTasks(cache.dbHandle())
-    // The run path's load — the lock, a plugin's `project` stage counted —
-    // so the doctor's task count is the number a run would see. No lock, or
-    // one a run would refuse, counts zero: broken configs are `vx lock`'s
-    // to report.
-    try {
-      const loaded = await loadProjects({
-        workspaceRoot: root,
-        cacheDir,
-        plugins,
-        projectMetas: metas,
-        seeds: 'all',
-        closure: false,
-        configs: lock,
-        warn,
-      })
-      for (const p of loaded.projects.values()) {
-        const tasks = p.config.tasks ?? {}
-        taskCount += Object.keys(tasks).length
-        for (const t of Object.values(tasks)) if (t?.exec?.sandbox !== undefined) sandboxed++
-      }
-    } catch (err) {
-      if (!isUserError(err)) throw err
-      taskCount = 0
-      sandboxed = 0
+    const loaded = await loadProjects({
+      workspaceRoot: root,
+      cacheDir,
+      plugins,
+      projectMetas: metas,
+      seeds: 'all',
+      closure: false,
+      configs: lock,
+      warn,
+    })
+    for (const p of loaded.projects.values()) {
+      const tasks = p.config.tasks ?? {}
+      taskCount += Object.keys(tasks).length
+      for (const t of Object.values(tasks)) if (t?.exec?.sandbox !== undefined) sandboxed++
     }
-  } finally {
-    cache.close()
+  } catch (err) {
+    if (!isUserError(err)) throw err
+    taskCount = 0
+    sandboxed = 0
   }
 
   const lockPresent = await Bun.file(lockfilePath(root)).exists()
+  // No lock is its own row, `lockfile`.
+  const lockError = lockPresent ? refused : null
   // Asked while the probe runs: each is a synchronous spawn.
   const git = gitVersion()
   const statusCache = gitStatusCache(root)
   const sandbox = { ...(await probing), declared: sandboxed }
-  const cacheStore = cache.storeDir ?? storeRoot
+  const cacheStore = indexStore ?? storeRoot
   return {
     vx: VERSION,
     vxPath: vxPath(),
-    handedOffFrom: process.env['VX_HANDED_OFF'] ?? null,
+    handedOffFrom: process.env['VX_HANDED_OFF'] || null,
     // An unsupported Bun does not stop a run, it makes the run's ANSWERS
     // wrong (util/bun-version.ts measures which). The row a reader already
     // consults for "is my setup sane" is where that belongs: a warning on
@@ -257,6 +331,7 @@ async function collectWorkspaceInfo(
     schemaVersion: SCHEMA_VERSION,
     cacheEntries: stats.entryCount,
     cacheBytes: stats.totalBytes,
+    cacheIndexError: indexError,
     settings: settingsFact(workspaceConfig),
     // A row-less artifact is indexed again only when its task asks for its
     // key; the rest only `vx cache clean` reclaims (after an upgrade's
@@ -270,6 +345,7 @@ async function collectWorkspaceInfo(
     // this is the workspace's standing list.
     flakyTasks: flaky,
     lockfile: lockPresent,
+    lockError,
     sandbox,
   }
 }
@@ -339,7 +415,7 @@ function memoryFact(): InfoFacts['memory'] {
  * the warm run (STATUS, waves 5 and the 2026-09-03 refutations) — the
  * status walk's cost is git's own, and vx already overlaps it.
  */
-function gitStatusCache(root: string): InfoFacts['gitStatusCache'] {
+export function gitStatusCache(root: string): InfoFacts['gitStatusCache'] {
   try {
     const p = Bun.spawnSync({
       cmd: [executablePath('git'), 'config', '--get-regexp', '^core\\.(fsmonitor|untrackedcache)$'],
@@ -351,9 +427,25 @@ function gitStatusCache(root: string): InfoFacts['gitStatusCache'] {
     // exit 1 is git's "no key matched": both off, still an answer.
     if (p.exitCode !== 0 && p.exitCode !== 1) return null
     const out = p.exitCode === 0 ? new TextDecoder().decode(p.stdout) : ''
-    const on = (key: string): boolean =>
-      new RegExp(`^core\\.${key} (true|1|yes|on)$`, 'im').test(out)
-    return { fsmonitor: on('fsmonitor'), untrackedCache: on('untrackedcache') }
+    // The last value set wins, as git reads it (a global `true` under a
+    // repo's `false` is off), and a key with no `=` is true.
+    const last = new Map<string, string | null>()
+    for (const line of out.split('\n')) {
+      if (line === '') continue
+      const sp = line.indexOf(' ')
+      last.set(
+        (sp === -1 ? line : line.slice(0, sp)).toLowerCase(),
+        sp === -1 ? null : line.slice(sp + 1),
+      )
+    }
+    const on = (key: string, hook: boolean): boolean => {
+      const v = last.get(`core.${key}`)
+      if (v === undefined) return false
+      if (v === null || /^(true|yes|on|1)$/i.test(v)) return true
+      // core.fsmonitor may name a hook command instead of a boolean.
+      return hook && v !== '' && !/^(false|no|off|0)$/i.test(v)
+    }
+    return { fsmonitor: on('fsmonitor', true), untrackedCache: on('untrackedcache', false) }
   } catch {
     return null
   }

package/src/orchestrator/execute-args.ts

@@ -71,7 +71,10 @@ export function executeArgsOf(
     if (placements.remoteOnly.has(id)) a.remoteOnly = true
     if (placements.carried.has(id)) a.carried = true
     const servers = placements.servers.get(id)
-    if (servers !== undefined) a.servers = servers
+    if (servers !== undefined) {
+      a.servers = servers
+      a.serversNested = servers.map((s) => facts.nestedDirsByProject.get(s.projectName) ?? [])
+    }
     if (probe !== undefined) a.preProbed = probe
     if (upfrontKey !== undefined) a.upfrontKey = upfrontKey
     if (upfrontGroupKey !== undefined) a.upfrontGroupKey = upfrontGroupKey