@vzn/vx 0.0.651 → 0.0.653

package/src/cli/select.ts

@@ -25,10 +25,10 @@ import {
   type ProjectMeta,
   readLockfile,
 } from '../workspace/index.js'
-import type { ProjectConfig } from '../config.js'
+import type { ProjectConfig, TaskConfig } from '../config.js'
 import type { ProjectEntry } from '../workspace/index.js'
 import { isDefaultBuild, parseDependencySpec } from '../graph/index.js'
-import { declaresInput, workspaceFilesReachInto } from '../cache/index.js'
+import { declaresInput, lazyGitEnumeration, workspaceFilesReachInto } from '../cache/index.js'
 import {
   isUserError,
   listed,
@@ -45,7 +45,6 @@ import {
   claimedExtraFiles,
   claimedDigests,
   fingerprintClaims,
-  gitOfDiscovery,
   hasHook,
   keepDiscoveryGraph,
 } from '../orchestrator/index.js'
@@ -77,17 +76,53 @@ export async function workspaceGlobOwners(
   nested: readonly string[] = [],
   /** `AffectedChanges.dirLinks`. */
   dirLinks: ReadonlySet<string> = new Set(),
+  /** `AffectedChanges.untracked`. */
+  untracked: ReadonlySet<string> = new Set(),
 ): Promise<string[]> {
-  const declaresMatch = (config: ProjectConfig): boolean => {
+  // The changed paths a `workspaceFiles` list matches, asked once per
+  // distinct list rather than once per task: tasks × changed paths was
+  // 14.5 s on 8000 projects with 64k changed paths. A tracked match selects
+  // any task declaring the list; an untracked one only a task whose own
+  // outputs it is not, so those are kept for the per-task check.
+  const byList = new Map<string, { tracked: boolean; loose: string[] }>()
+  const matchesOf = (ws: readonly string[]) => {
+    const key = ws.join('\0')
+    let found = byList.get(key)
+    if (found !== undefined) return found
+    found = { tracked: false, loose: [] }
+    const probe = { inputs: { files: [], workspaceFiles: ws } } as unknown as TaskConfig
+    for (const rel of changed) {
+      const loose = untracked.has(rel)
+      if (!declaresInput(probe, null, rel, dirLinks.has(rel))) continue
+      if (!loose) {
+        found.tracked = true
+        break
+      }
+      found.loose.push(rel)
+    }
+    byList.set(key, found)
+    return found
+  }
+  const declaresMatch = (config: ProjectConfig, projectAbs: string): boolean => {
+    let projectDir: string | undefined
     for (const task of Object.values(config.tasks ?? {})) {
-      if (changed.some((rel) => declaresInput(task, null, rel, dirLinks.has(rel)))) return true
+      const ws = task.inputs?.workspaceFiles
+      if (ws === undefined || ws.length === 0) continue
+      const input = (rel: string): boolean => {
+        const loose = untracked.has(rel)
+        if (loose) projectDir ??= relPosix(root, projectAbs)
+        return declaresInput(task, null, rel, dirLinks.has(rel), loose, projectDir)
+      }
+      // A hand-edited lock entry that is no list is asked path by path.
+      const found = Array.isArray(ws) ? matchesOf(ws) : { tracked: changed.some(input), loose: [] }
+      if (found.tracked || found.loose.some(input)) return true
       if (nested.some((dir) => workspaceFilesReachInto(task, dir))) return true
     }
     return false
   }
   try {
     const staged = await stagedLoad()
-    return [...staged.values()].filter((p) => declaresMatch(p.config)).map((p) => p.name)
+    return [...staged.values()].filter((p) => declaresMatch(p.config, p.dir)).map((p) => p.name)
   } catch {
     // Fall through to the per-file sweep.
   }
@@ -102,7 +137,7 @@ export async function workspaceGlobOwners(
     const dir = lockKey(root, meta.dir)
     if (!Object.hasOwn(lock.projects, dir)) continue
     try {
-      if (declaresMatch(lock.projects[dir]!.config)) owners.push(meta.name)
+      if (declaresMatch(lock.projects[dir]!.config, meta.dir)) owners.push(meta.name)
     } catch {
       // A hand-edited entry that will not read cannot be shown to declare a
       // matching glob; surfacing it here would fail a run the load tolerates.
@@ -287,6 +322,12 @@ function refusalOf(err: unknown): Refusal {
     : { error: err.message }
 }
 
+/** The filter `--affected` became; `env` is the `VX_AFFECTED_BASE` value that gave its base. */
+export interface AffectedFilter {
+  readonly filter: string
+  readonly env?: string
+}
+
 /**
  * The filter `--affected[=<base>]` stands for: `...[<base>]`, the changed
  * projects and their dependents. An empty base is `VX_AFFECTED_BASE`'s,
@@ -298,9 +339,10 @@ export async function affectedFilterFor(
   affected: string,
   /** What the verb does instead on the base branch (`defaultAffectedBase`). */
   instead?: string,
-): Promise<string | Refusal> {
+): Promise<AffectedFilter | Refusal> {
   const root = await findWorkspaceRoot(cwd)
-  let base = affected || ((settingEnv('affectedBase') as string | undefined) ?? '')
+  const env = affected === '' ? (settingEnv('affectedBase') as string | undefined) : undefined
+  let base = affected || (env ?? '')
   if (base === '') {
     const ws = await loadCliWorkspace(root)
     try {
@@ -312,42 +354,98 @@ export async function affectedFilterFor(
       return refusalOf(err)
     }
   }
-  return `...[${base}]`
+  return env === undefined ? { filter: `...[${base}]` } : { filter: `...[${base}]`, env }
 }
 
 export async function resolveFilters(
   cwd: string,
   raw: string[],
   load: CliLoadOptions = {},
-  /** The raw filter `--affected` became: its diff is kept per path for the run. */
-  affected?: string,
+  /** The filter `--affected` became: its diff is kept per path for the run. */
+  affected?: AffectedFilter,
   /** The verb a warning names: `vx show` and `vx watch` select as a run does. */
   verb: 'run' | 'show' | 'watch' = 'run',
 ): Promise<FilterResolution> {
   const root = await findWorkspaceRoot(cwd)
-  const projects = await loadWorkspaceProjects(cwd, load)
   let parsed: ReturnType<typeof parseFilter>[]
   try {
     parsed = raw.map((r) => parseFilter(r, root))
   } catch (err) {
+    await loadWorkspaceProjects(cwd, load)
     return refusalOf(err)
   }
+  // A filter that diffs against git reads its untracked files from the
+  // run's whole-tree walk (one walk where it spawned its own), and the run
+  // reuses it with the discovery (I-26). The walk needs only the root, so
+  // it starts before the workspace config and discovery, not after them.
+  const git = parsed.some((f) => f.gitSince !== undefined) ? lazyGitEnumeration(root) : undefined
+  void git?.start()
+  const discovering = discoverCliProjects(root, load, git)
+  discovering.catch(() => {})
   // `sinceViaDeps` (`e2e...[main]`) walks the changed projects' dependents.
   const walksGraph = parsed.some(
     (f) => f.withDeps || f.withDependents || f.onlyDeps || f.sinceViaDeps === true,
   )
-  // A filter that diffs against git starts the run's whole-tree walk now:
-  // the diff reads its untracked files from it (one walk where it spawned
-  // its own), and the run reuses it with the discovery (I-26).
-  const git = parsed.some((f) => f.gitSince !== undefined) ? gitOfDiscovery(projects) : undefined
-  void git?.start()
   // Every reader of the staged configs in this pass — the `pkg#task`
   // edge walk, the `workspaceFiles` owners of a changed path — shares
   // ONE load, and the run reuses it (`RunOptions.staged`): the `project`
   // stage runs once per project per run.
   let stagedPromise: Promise<Map<string, ProjectEntry>> | undefined
   const stagedOnce = (): Promise<Map<string, ProjectEntry>> =>
-    (stagedPromise ??= loadCliProjects(root, projects, 'all', load))
+    (stagedPromise ??= discovering.then((projects) => loadCliProjects(root, projects, 'all', load)))
+  // A scoped enumeration lists only its projects: null asks git.
+  const enumeration = async () => (git === undefined ? undefined : await git.start())
+  // Each `[<since>]` diff starts now, before discovery ends: merge-base and
+  // diff need only the root and the ref, so they overlap the workspace
+  // config, discovery and the config load, where they waited on all three.
+  // One after another, as a shallow clone's fetches must be; each is
+  // awaited in filter order below, so a refusal comes where it came.
+  const diffs = new Map<(typeof parsed)[number], Promise<AffectedChanges | Set<string>>>()
+  let previous: Promise<unknown> | undefined
+  for (const f of parsed) {
+    if (f.gitSince === undefined) continue
+    const args: Parameters<typeof affectedChanges>[0] = {
+      workspaceRoot: root,
+      since: f.gitSince,
+      projects: discovering,
+      workspaceGlobOwners: async (
+        changed: readonly string[],
+        nested: readonly string[],
+        dirLinks: ReadonlySet<string>,
+        untracked: ReadonlySet<string>,
+      ) =>
+        workspaceGlobOwners(
+          root,
+          await discovering,
+          changed,
+          load,
+          stagedOnce,
+          nested,
+          dirLinks,
+          untracked,
+        ),
+      fingerprintClaims: async () => workspaceFingerprintClaims(root, await discovering, load),
+      untracked: async () => (await enumeration())?.untracked ?? null,
+      links: async () => {
+        const g = await enumeration()
+        if (g === undefined || !g.scopes.includes('.')) return null
+        const out: string[] = []
+        for (const [rel, oid] of g.trusted) if (oid.startsWith('120000:')) out.push(rel)
+        return out
+      },
+      flagged: async () => {
+        const g = await enumeration()
+        return g !== undefined && g.scopes.includes('.') ? g.flagged : null
+      },
+    }
+    const diff = (): Promise<AffectedChanges | Set<string>> =>
+      f.raw === affected?.filter ? affectedChanges(args) : affectedProjects(args)
+    const started = previous === undefined ? diff() : previous.then(diff)
+    started.catch(() => {})
+    diffs.set(f, started)
+    previous = started
+  }
+  const projects = await discovering
   let edges: Map<string, string[]> | undefined
   if (walksGraph) {
     try {
@@ -367,50 +465,34 @@ export async function resolveFilters(
     }
   }
   const graph = buildPackageGraph(projects, edges)
-  // The graph a run reusing this discovery builds is this one when no task
-  // edge went into it.
-  if (edges === undefined) keepDiscoveryGraph(projects, graph)
+  // The graph a run reusing this discovery builds is this one when the task
+  // edges added none: each is a discovered edge already, or names no project.
+  const known = new Set(projects.map((p) => p.name))
+  if (
+    edges === undefined ||
+    projects.every((p) =>
+      (edges.get(p.name) ?? []).every((t) => !known.has(t) || p.deps?.includes(t) === true),
+    )
+  )
+    keepDiscoveryGraph(projects, graph)
 
-  // Resolve every `[<since>]` filter against git before the pure
-  // applyFilters pass runs. One spawn per distinct ref — usually
-  // there's only one anyway.
+  // Every `[<since>]` filter's diff, started above, is in before the pure
+  // applyFilters pass runs.
   const affectedByFilter = new Map<(typeof parsed)[number], Set<string>>()
+  // The diffs that named a change, though maybe in no project: a root file
+  // no task declares. Then the tree is not clean against HEAD.
+  const changedAny = new Set<(typeof parsed)[number]>()
   let changes: AffectedChanges | undefined
-  for (const f of parsed) {
-    if (f.gitSince === undefined) continue
+  for (const [f, diff] of diffs) {
     try {
-      const args = {
-        workspaceRoot: root,
-        since: f.gitSince,
-        projects,
-        workspaceGlobOwners: (
-          changed: readonly string[],
-          nested: readonly string[],
-          dirLinks: ReadonlySet<string>,
-        ) => workspaceGlobOwners(root, projects, changed, load, stagedOnce, nested, dirLinks),
-        fingerprintClaims: () => workspaceFingerprintClaims(root, projects, load),
-        ...(git !== undefined
-          ? {
-              untracked: async () => (await git.start()).untracked,
-              // A scoped enumeration lists only its projects: null asks git.
-              links: async () => {
-                const g = await git.start()
-                if (!g.scopes.includes('.')) return null
-                const out: string[] = []
-                for (const [rel, oid] of g.trusted) if (oid.startsWith('120000:')) out.push(rel)
-                return out
-              },
-              flagged: async () => {
-                const g = await git.start()
-                return g.scopes.includes('.') ? g.flagged : null
-              },
-            }
-          : {}),
-      }
+      const answer = await diff
       let names: Set<string>
-      if (f.raw === affected) {
-        changes = await affectedChanges(args)
+      if (answer instanceof Set) {
+        names = answer
+      } else {
+        changes = answer
         names = changes.projects
+        if (changes.changed.length > 0 || changes.nested !== undefined) changedAny.add(f)
         // A `graph` plugin may tie any task to a changed path (an edge, an
         // input), and the run alone builds that graph: every project is a
         // candidate, and the run keeps the tasks its final graph reaches.
@@ -420,12 +502,18 @@ export async function resolveFilters(
         ) {
           names = new Set(projects.map((p) => p.name))
         }
-      } else {
-        names = await affectedProjects(args)
       }
       affectedByFilter.set(f, names)
     } catch (err) {
-      return refusalOf(err)
+      const refusal = refusalOf(err)
+      // A base the variable gave was reported as if typed.
+      if (
+        affected?.env !== undefined &&
+        f.raw === affected.filter &&
+        refusal.code === 'VX_E_AFFECTED_BASE'
+      )
+        return { ...refusal, error: `VX_AFFECTED_BASE=${affected.env}: ${refusal.error}` }
+      return refusal
     }
   }
 
@@ -482,10 +570,14 @@ export async function resolveFilters(
         // the branch under test) can never mark anything affected, and this
         // exit-0 note was the only sign (CI persona, 2026-09-16). Say so.
         const self = includes.map((f) => headBase(root, f.gitSince!)).find((b) => b !== undefined)
+        // `HEAD` asked by name checks uncommitted work: "HEAD is HEAD itself"
+        // read as nonsense for a valid question.
         const hint =
-          self === undefined
+          self === undefined || (self === 'HEAD' && includes.some((f) => changedAny.has(f)))
             ? ''
-            : ` — ${self} is HEAD itself: compare with the branch you merge into (--affected=origin/main) or the previous commit (--affected=HEAD~1)`
+            : self === 'HEAD'
+              ? ' — the working tree has no change against HEAD; to compare commits, use the branch you merge into (--affected=origin/main) or the previous commit (--affected=HEAD~1)'
+              : ` — ${self} is HEAD itself: compare with the branch you merge into (--affected=origin/main) or the previous commit (--affected=HEAD~1)`
         return { empty: `nothing affected since ${refs}${hint}` }
       }
       // The diff matched and a walk or an exclusion left nothing: still the
@@ -507,7 +599,11 @@ export async function resolveFilters(
     // app, and `--affected` a `...[<base>]` nobody typed.
     const hint =
       (await unlockedHint(root, parsed, unmatched)) ?? didYouMean(unmatched, projects, tags)
-    return { error: `no projects matched filter(s): ${unmatched.join(', ')}${hint}` }
+    // Quoted, as the warning below quotes it: bare, `apq...` and the hint's
+    // full stop read `apq....` in the flat message `--format json` carries.
+    return {
+      error: `no projects matched filter(s): ${unmatched.map((f) => `"${f}"`).join(', ')}${hint}`,
+    }
   }
   // Something matched, so the run proceeds; a pattern that matched nothing
   // alongside it is still worth a line — it is probably a typo.
@@ -520,7 +616,7 @@ export async function resolveFilters(
   // Each include is a union: what `--filter other` selected runs its tasks
   // whether or not the `--affected` diff reaches them, and an exclude
   // still removes it (X-10).
-  const others = parsed.filter((f) => f.negate || f.raw !== affected)
+  const others = parsed.filter((f) => f.negate || f.raw !== affected?.filter)
   const outright =
     changes !== undefined && others.some((f) => !f.negate)
       ? [

package/src/cli/show.ts

@@ -6,11 +6,12 @@
 // resolved config. `<pkg>#<task>`: one task. `<task>`: that task in every
 // project declaring it.
 
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { ProjectConfig, TaskConfig } from '../config.js'
 import { declaredTask } from '../graph/index.js'
 import { isDefaultBuild } from '../graph/index.js'
-import { affectedTaskProjects } from '../orchestrator/index.js'
+import { affectedTaskProjects, projectAtDir, unlockedDir } from '../orchestrator/index.js'
 import { flagHint, formatValue, refuse, seeHelp } from './help.js'
 import {
   listed,
@@ -22,7 +23,7 @@ import {
 } from '../util/index.js'
 import * as ui from '../ui/index.js'
 import { sayNotice } from '../ui/index.js'
-import { affectedFilterFor, resolveFilters } from './select.js'
+import { type AffectedFilter, affectedFilterFor, resolveFilters } from './select.js'
 import {
   discoverCliProjects,
   loadCliProjects,
@@ -34,6 +35,7 @@ import {
   buildPackageGraph,
   EMPTY_LOCK,
   findWorkspaceRoot,
+  PROJECT_CONFIG_FILENAMES,
   type ProjectEntry,
   type ProjectMeta,
 } from '../workspace/index.js'
@@ -113,6 +115,22 @@ export async function showCmd(args: readonly string[]): Promise<number> {
     }
     parsed.target = `${rootMeta.name}${parsed.target.slice(2)}`
   }
+  // A project's directory typed for its name: by edit distance, `p/a`
+  // hinted `p/b`, another project.
+  const atDir = (typed: string, suffix: string): string | undefined => {
+    const name = projectAtDir(typed, root, metas)
+    return name === undefined ? undefined : ` — did you mean ${name}${suffix}?`
+  }
+  // A directory whose config came after the lock: the line `vx run` gives,
+  // not "unknown project" and a guess.
+  const refuseUnlocked = async (typed: string): Promise<void> => {
+    const config = await unlockedDir(typed, metas, root)
+    if (config === undefined) return
+    throw new UserError(
+      `${parsed.target}: ${relPosix(root, config)} is not in the lock yet — run \`vx lock\``,
+      'VX_E_LOCK',
+    )
+  }
   const hashAt = parsed.target?.indexOf('#') ?? -1
   const projectName =
     parsed.target === undefined
@@ -136,8 +154,9 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   }
   if (projectName !== undefined && (taskName !== undefined || byName.has(projectName))) {
     if (!byName.has(projectName)) {
+      await refuseUnlocked(projectName)
       throw new UserError(
-        `vx show: unknown project: "${projectName}"${suggest(projectName, [...byName.keys()], '', 'projects')}`,
+        `vx show: unknown project: "${projectName}"${atDir(projectName, `#${taskName}`) ?? suggest(projectName, [...byName.keys()], '', 'projects')}`,
         'VX_E_UNKNOWN_PROJECT',
       )
     }
@@ -161,16 +180,16 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       )
     }
     const raw = [...parsed.filters]
-    let affected: string | undefined
+    let affected: AffectedFilter | undefined
     if (parsed.affected !== undefined) {
       const f = await affectedFilterFor(
         process.cwd(),
         parsed.affected,
         'drop --affected to list them all',
       )
-      if (typeof f === 'object') throw new UserError(`vx show: ${f.error}`, f.code ?? 'VX_E_USAGE')
+      if ('error' in f) throw new UserError(`vx show: ${f.error}`, f.code ?? 'VX_E_USAGE')
       affected = f
-      raw.unshift(f)
+      raw.unshift(f.filter)
     }
     const r = await resolveFilters(process.cwd(), raw, {}, affected, 'show')
     if ('error' in r) throw new UserError(`vx show: ${r.error}`, r.code ?? 'VX_E_USAGE')
@@ -203,13 +222,14 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       declares(declaredTask(p.config, projectName!)),
     )
     if (declaring.length === 0) {
+      await refuseUnlocked(projectName!)
       const names = new Set<string>()
       for (const p of projects.values())
         for (const [t, task] of Object.entries(p.config.tasks ?? {}))
           if (declares(task)) names.add(t)
       // `nx show projects` lists them; here a bare `vx show` does.
       const nx = projectName === 'projects' ? ' (`nx show projects` is `vx show` here)' : ''
-      const unknown = `vx show: unknown project or task: "${projectName}"${nx}${suggest(projectName!, [...byName.keys(), ...names], '', 'projects and tasks')}`
+      const unknown = `vx show: unknown project or task: "${projectName}"${nx}${atDir(projectName!, '') ?? suggest(projectName!, [...byName.keys(), ...names], '', 'projects and tasks')}`
       const base =
         parsed.spacedBase === projectName
           ? `${unknown.endsWith('.') ? '' : '.'} \`--affected\` takes its base with '=': --affected=${projectName}`
@@ -258,7 +278,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const dir = projectDir(root, meta)
 
   if (taskName === undefined) {
-    emit(renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format))
+    emit(renderProject(meta.name, dir, config, configNote(meta), parsed.format))
     return 0
   }
 
@@ -369,7 +389,9 @@ function renderList(
       tags: projects.get(meta.name)?.config.tags ?? [],
       tasks: Object.keys(tasks),
       onlyDefault: Object.values(tasks).every((t) => isDefaultBuild(t)),
+      hasDefault: Object.values(tasks).some((t) => isDefaultBuild(t)),
       configured: meta.configPath !== null,
+      note: configNote(meta),
     }
   })
   if (format === 'json') {
@@ -383,23 +405,38 @@ function renderList(
     // A package with no config file has only tasks a plugin gave it, or the
     // default `build` a configured dependant's closure gave it.
     const tasks = r.configured
-      ? count
-      : n === 0
-        ? 'no vx config'
-        : r.onlyDefault
-          ? `${count}, default build (no vx config)`
-          : `${count} from plugins (no vx config)`
+      ? r.tasks.length > 0 && r.hasDefault
+        ? `${count}, default build`
+        : count
+      : r.note !== null && r.note !== 'none'
+        ? r.note
+        : n === 0
+          ? 'no vx config'
+          : r.onlyDefault
+            ? `${count}, default build (no vx config)`
+            : `${count} from plugins (no vx config)`
     return [ui.id(r.name), r.dir, tasks, ...(anyTags ? [r.tags.join(', ')] : [])]
   })
   const columns = ['project', 'dir', 'tasks', ...(anyTags ? ['tags'] : [])]
   return [ui.section('Projects', String(rows.length), ui.table(columns, cells))]
 }
 
+/**
+ * Null for a project the lock holds a config for; else `none`, or a config
+ * written after the lock: "no vx config" sent a user who had just written
+ * one looking for a typo.
+ */
+function configNote(meta: ProjectMeta): string | null {
+  if (meta.configPath !== null) return null
+  const file = PROJECT_CONFIG_FILENAMES.find((n) => existsSync(path.join(meta.dir, n)))
+  return file === undefined ? 'none' : `${file} not locked — run vx lock`
+}
+
 function renderProject(
   name: string,
   dir: string,
   config: ProjectConfig | null,
-  hasConfigFile: boolean,
+  note: string | null,
   format: 'pretty' | 'json',
 ): Shown {
   if (format === 'json') {
@@ -414,11 +451,16 @@ function renderProject(
     ['dir', dir],
     ...(tags.length > 0 ? [['tags', tags.join(', ')] as const] : []),
     // A config-less package a dependant reaches has the default `build` (X-9).
-    ...(hasConfigFile ? [] : [['config', 'none'] as const]),
-    ...(tasks.length === 0 && hasConfigFile ? [['tasks', 'none declared'] as const] : []),
+    ...(note === null ? [] : [['config', note] as const]),
+    ...(tasks.length === 0 && note === null ? [['tasks', 'none declared'] as const] : []),
   ]
   const blocks = tasks.map(([taskName, task]) =>
-    joined([ui.text(ui.id(`${name}#${taskName}`)), ui.fields(taskRows(task))]),
+    joined([
+      isDefaultBuild(task)
+        ? ui.line('  ', ui.id(`${name}#${taskName}`), ui.dim('  default'))
+        : ui.text(ui.id(`${name}#${taskName}`)),
+      ui.fields(taskRows(task)),
+    ]),
   )
   return [ui.section(name, ui.fields(head), ...blocks)]
 }
@@ -507,17 +549,17 @@ function taskRows(raw: TaskConfig): ui.FieldRow[] {
     add('inputs.tasks', list(inputs.tasks))
     add('inputs.runtime', list(inputs.runtime))
     add('inputs.workspaceRuntime', list(inputs.workspaceRuntime))
+    add('inputs.stability.strategy', inputs.stability?.strategy)
+    add('inputs.stability.severity', inputs.stability?.severity)
   }
-  const cache = task.cache
-  if (cache !== undefined) {
-    add('outputs.files', list(cache.outputs.files))
-    add('outputs.workspaceFiles', list(cache.outputs.workspaceFiles))
-    add(
-      'outputs.clean',
-      cache.outputs.clean === undefined ? undefined : cache.outputs.clean ? 'yes' : 'no',
-    )
-    add('inputStability.strategy', cache.inputStability?.strategy)
-    add('inputStability.severity', cache.inputStability?.severity)
+  const outputs = task.outputs
+  if (outputs !== undefined) {
+    add('outputs.files', list(outputs.files))
+    add('outputs.workspaceFiles', list(outputs.workspaceFiles))
+    add('outputs.clean', outputs.clean === undefined ? undefined : outputs.clean ? 'yes' : 'no')
   }
+  // The first question `vx why` raises ("declares no `cache: true`"), which
+  // only --format json answered.
+  if (task.cache === true) add('cache', 'yes')
   return rows
 }

package/src/cli/task-verb.ts

@@ -68,20 +68,25 @@ export async function nxTargetHint(tasks: readonly string[], cwd: string): Promi
 }
 
 /**
- * The task names `vx run <task>` can take here: the cwd project's, else
- * every project's, sorted; null when no workspace loads. What a run with
- * no task and no terminal for the picker names instead of a guess.
+ * The task names `vx run <task>` can take in the asked scope (`asked`: the
+ * projects `--filter` / `--affected` selected, or `all`), else the cwd
+ * project's, else every project's, sorted; null when no workspace loads.
+ * What a run with no task and no terminal for the picker names instead of
+ * a guess.
  */
-export async function taskNamesHere(cwd: string): Promise<string[] | null> {
+export async function taskNamesHere(
+  cwd: string,
+  asked?: ReadonlySet<string> | 'all',
+): Promise<{ names: string[]; inProject: boolean } | null> {
   const projects = await workspaceProjects(cwd)
   if (projects === null) return null
-  const own = await findCwdProject(cwd)
+  const own = asked === undefined ? await findCwdProject(cwd) : null
   const names = new Set<string>()
   for (const p of projects.values())
-    if (own === null || p.name === own)
+    if (typeof asked === 'object' ? asked.has(p.name) : own === null || p.name === own)
       for (const [t, task] of Object.entries(p.config.tasks ?? {}))
         if (!isDefaultBuild(task)) names.add(t)
-  return [...names].sort()
+  return { names: [...names].sort(), inProject: own !== null }
 }
 
 /**