@vzn/vx 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.28",
-    "@vzn/vx-linux-arm64": "0.0.28",
-    "@vzn/vx-darwin-x64": "0.0.28",
-    "@vzn/vx-darwin-arm64": "0.0.28"
+    "@vzn/vx-linux-x64": "0.0.30",
+    "@vzn/vx-linux-arm64": "0.0.30",
+    "@vzn/vx-darwin-x64": "0.0.30",
+    "@vzn/vx-darwin-arm64": "0.0.30"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/run.ts

@@ -461,6 +461,7 @@ export async function resolveRunOptions(
   const anchoredTasks = tasks.filter((t) => t.includes('#'))
   let projects: string[] | undefined
   let staged: RunOptions['staged']
+  let selectedByDiff = false
   if (bareTasks.length === 0) {
     projects = undefined
   } else if (filterStrings.length > 0) {
@@ -480,6 +481,7 @@ export async function resolveRunOptions(
       projects = []
     } else {
       projects = resolved.names
+      selectedByDiff = resolved.byDiff
       // The graph walk staged every config; the run reuses those entries
       // instead of evaluating and staging them a second time.
       staged = resolved.staged
@@ -515,6 +517,7 @@ export async function resolveRunOptions(
     opts.excludeDependencies = parsed.excludeDependencies
   }
   if (projects !== undefined) opts.projects = projects
+  if (selectedByDiff) opts.selectedByDiff = true
   if (staged !== undefined) opts.staged = staged
   if (parsed.retries !== undefined) opts.retries = parsed.retries
   if (parsed.timeout !== undefined) opts.timeout = parsed.timeout
@@ -582,6 +585,10 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       return 1
     }
     if (plan.tasks.length === 0) {
+      if (opts.selectedByDiff === true) {
+        process.stderr.write(`vx run: no affected project declares task(s): ${tasks.join(', ')}.\n`)
+        return 0
+      }
       process.stderr.write(`vx run: no projects declare task(s): ${tasks.join(', ')}.\n`)
       return 1
     }

package/src/cli/select.ts

@@ -127,6 +127,8 @@ export async function findCwdProject(cwd: string): Promise<string | null> {
 export type FilterResolution =
   | {
       names: string[]
+      /** An include filter was a git diff (`[ref]`, `--affected`): `RunOptions.selectedByDiff`. */
+      byDiff: boolean
       /** The staged load the graph walk needed, for the run to reuse (`RunOptions.staged`). */
       staged?: ReadonlyMap<string, ProjectEntry>
     }
@@ -269,7 +271,11 @@ export async function resolveFilters(
       staged = undefined
     }
   }
-  return { names: [...selected].sort(), ...(staged !== undefined ? { staged } : {}) }
+  return {
+    names: [...selected].sort(),
+    byDiff: parsed.some((f) => !f.negate && f.gitSince !== undefined),
+    ...(staged !== undefined ? { staged } : {}),
+  }
 }
 
 export interface PickedTask {

package/src/orchestrator/options.ts

@@ -20,6 +20,15 @@ export interface RunOptions {
    */
   tasks: readonly string[]
   projects?: string[]
+  /**
+   * `projects` came from a git diff (`--affected`, a `[ref]` filter), so
+   * which projects hold a bare task name depends on what changed: a name
+   * the changed projects do not declare is not a typo when the workspace
+   * declares it elsewhere, and a run with nothing left to do is clean.
+   * Judged against the scope, a docs-only commit turned
+   * `vx run test --affected` red (item 1024).
+   */
+  selectedByDiff?: boolean
   /**
    * Configs a selection pass in this same process already loaded and
    * staged with the same `cacheDir` and `frozen` (the CLI walks every

package/src/orchestrator/plugin-host.ts

@@ -277,7 +277,10 @@ export async function applyScheduleHooks(
  * `admit` stage, built once per run into the predicate the scheduler asks
  * at every local dispatch: every plugin that answers must admit. A plugin
  * that throws is reported once and admits from then on — a policy never
- * breaks a run — so the predicate is never the reason a task hangs.
+ * breaks a run — and one that refuses while nothing local is running is
+ * overridden with a word, since only a completion asks again: that
+ * refusal stalled the run for good (item 1023). So the predicate is never
+ * the reason a task hangs.
  * Undefined when no plugin answers, which keeps the scheduler on its
  * count-only path.
  */
@@ -290,6 +293,7 @@ export function buildAdmission(
   const answering = plugins.filter((p) => p.admit !== undefined)
   if (answering.length === 0) return undefined
   const broken = new Set<VxPlugin>()
+  const overridden = new Set<VxPlugin>()
   return (id, running) => {
     // The scheduler asks only about ids in this same map, so the lookup
     // always lands: an unknown-id arm here was deleted with the whole core
@@ -302,7 +306,14 @@ export function buildAdmission(
     for (const plugin of answering) {
       if (broken.has(plugin)) continue
       try {
-        if (plugin.admit!(task, ctx) === false) return false
+        if (plugin.admit!(task, ctx) !== false) continue
+        if (running.size > 0) return false
+        if (!overridden.has(plugin)) {
+          overridden.add(plugin)
+          warn(
+            `plugin '${plugin.name}' refused ${id} in admit with nothing running; admitting it, since no completion would ask again`,
+          )
+        }
       } catch (err) {
         broken.add(plugin)
         const m = err instanceof Error ? err.message : String(err)

package/src/orchestrator/prepare.ts

@@ -131,11 +131,14 @@ export interface PreparedRun {
    *     user's task names were resolved against `projects`. Typically
    *     a typo'd task name; `run()` treats this as a CI footgun and
    *     returns NOT-ok.
+   *   - `'none-affected'`     — as `'no-tasks-declared'`, but the scope
+   *     came from a diff and every name is declared somewhere else in the
+   *     workspace: nothing changed that runs them, a clean outcome.
    *   - `'empty-graph'`       — `requested` was non-empty but the
    *     graph builder still produced no nodes. Defensive; unreachable
    *     under current `buildTaskGraph` semantics.
    */
-  empty: null | 'no-tasks-declared' | 'empty-graph'
+  empty: null | 'no-tasks-declared' | 'none-affected' | 'empty-graph'
 }
 
 /**
@@ -286,7 +289,16 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     : [...projects.keys()]
 
   const requested = expandRequested(options.tasks, candidateProjects, projects)
-  const unresolvedTasks = unresolvedRequests(options.tasks, candidateProjects, projects)
+  let unresolvedTasks = unresolvedRequests(options.tasks, candidateProjects, projects)
+  if (
+    options.selectedByDiff === true &&
+    projects.size < projectsWithConfigs.length &&
+    unresolvedTasks.some((t) => !t.includes('#'))
+  ) {
+    unresolvedTasks = await declaredNowhere(unresolvedTasks, () =>
+      loadProjects({ ...loadArgs, seeds: 'all', closure: false, staged: projects }),
+    )
+  }
 
   // Cache seam precedence: an EXPLICITLY injected remote layer
   // (RunOptions.remoteCache — a distribution agent or daemon that already
@@ -369,7 +381,10 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       gitFilesCache,
       hashCache,
       workspaceProjectCount: projectMetas.length,
-      empty: 'no-tasks-declared',
+      empty:
+        options.selectedByDiff === true && unresolvedTasks.length === 0
+          ? 'none-affected'
+          : 'no-tasks-declared',
     }
   }
 
@@ -460,6 +475,29 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   }
 }
 
+/**
+ * The names in `unresolved` no project in the whole workspace declares: an
+ * anchored `pkg#task` stays as it is, a bare name leaves when a config the
+ * diff's scope left out declares it. `load` evaluates those configs; one
+ * failing to load leaves every name as it was, so the guard still speaks.
+ */
+async function declaredNowhere(
+  unresolved: readonly string[],
+  load: () => Promise<LoadedProjects>,
+): Promise<string[]> {
+  let all: LoadedProjects
+  try {
+    all = await load()
+  } catch {
+    return [...unresolved]
+  }
+  const declared = new Set<string>()
+  for (const p of all.projects.values()) {
+    for (const t of Object.keys(p.config.tasks ?? {})) declared.add(t)
+  }
+  return unresolved.filter((t) => t.includes('#') || !declared.has(t))
+}
+
 /**
  * Refuses the first `^name` in `unproven` that no project in the whole
  * workspace declares. `load` evaluates the configs a scoped run left out;

package/src/orchestrator/run.ts

@@ -259,6 +259,12 @@ async function runOnBus(
     prepared.cache.close()
     return { ok: false, outcomes: [] }
   }
+  if (prepared.empty === 'none-affected') {
+    log.status(`No affected project declares task(s): ${options.tasks.join(', ')}.`)
+    await teardown()
+    prepared.cache.close()
+    return { ok: true, outcomes: [] }
+  }
   if (prepared.empty !== null) {
     // `no-tasks-declared` is almost always a typo in CI; we surface
     // a clear message and return NOT-ok so the script exits 1.