@vzn/vx 0.0.607 → 0.0.609

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.607",
+  "version": "0.0.609",
   "description": "The fastest task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.607",
-    "@vzn/vx-linux-arm64": "0.0.607",
-    "@vzn/vx-darwin-x64": "0.0.607",
-    "@vzn/vx-darwin-arm64": "0.0.607"
+    "@vzn/vx-linux-x64": "0.0.609",
+    "@vzn/vx-linux-arm64": "0.0.609",
+    "@vzn/vx-darwin-x64": "0.0.609",
+    "@vzn/vx-darwin-arm64": "0.0.609"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/run.ts

@@ -11,7 +11,6 @@ import {
   run as runOrchestrator,
   shellQuote,
   type RunOptions,
-  type RunResult,
 } from '../orchestrator/index.js'
 import type { ContinueMode, TaskOutcome } from '../graph/index.js'
 import {
@@ -721,6 +720,12 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       return 1
     }
     if (plan.tasks.length === 0) {
+      // The run's own line: a dry run that guessed from the scope alone
+      // said no affected project declared a task one did (X-141).
+      if (plan.noneAffected !== undefined) {
+        process.stderr.write(`${plan.noneAffected}\n`)
+        return 0
+      }
       if (opts.selectedByDiff === true) {
         process.stderr.write(`vx run: no affected project declares task(s): ${tasks.join(', ')}.\n`)
         return 0

package/src/orchestrator/plan.ts

@@ -82,6 +82,8 @@ export interface RunPlan {
   unresolvedTasks?: readonly string[]
   /** What `vx run` appends to that refusal: the nearest declared names, or how to declare one. */
   unresolvedHint?: string
+  /** Set when `--affected` left nothing to run: the line the run would print, and why. */
+  noneAffected?: string
   /**
    * Producers `--download` WANTED to defer but could not, mapped to why.
    * Without this the gate is invisible: a user asks for `--download=none`,

package/src/orchestrator/projects.ts

@@ -9,6 +9,7 @@ import type { ProjectConfig, TaskConfig } from '../config.js'
 import {
   frozenProjectConfigs,
   loadProjectConfigs,
+  LOCKFILE_NAME,
   validateProjectConfig,
   type LoadProjectConfigOptions,
   type LoadReads,
@@ -243,6 +244,21 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
   // alike. With no root project it stays, and the graph's refusal says so.
   const root = path.resolve(workspaceRoot)
   const rootName = args.projectMetas.find((m) => path.resolve(m.dir) === root)?.name
+  // A project the lock holds whose config file is gone ran nothing under
+  // --frozen, green, though the lock promises what runs is what was
+  // locked (X-144); a run never even asks such a project for a task.
+  // Refused as a moved config is (D-88). With no lock at all, nothing was
+  // locked: a repo of config-less projects needs none.
+  if (lock) {
+    const bare = args.projectMetas.filter((m) => m.configPath === null)
+    const held = bare.length === 0 ? null : await lock().catch(() => null)
+    const gone = held === null ? undefined : bare.find((m) => Object.hasOwn(held.projects, m.name))
+    if (gone !== undefined && held !== null)
+      throw new UserError(
+        `${LOCKFILE_NAME} locks "${gone.name}" at ${held.projects[gone.name]!.configPath}, but it has no config now — ` +
+          `run \`vx lock\` to refresh, or delete ${LOCKFILE_NAME}`,
+      )
+  }
   const projects = new Map<string, ProjectEntry>()
   while (pending.length > 0) {
     const round = pending.splice(0, pending.length)

package/src/orchestrator/run.ts

@@ -404,20 +404,7 @@ async function runOnBus(
     return { ok: false, outcomes: [], refused }
   }
   if (prepared.empty === 'none-affected') {
-    // A changed project declares the task, so `--affected`'s task walk is
-    // what left nothing (affected-tasks.ts), not the scope.
-    const inScope = new Set(options.projects ?? [])
-    const reachedNone =
-      options.affected !== undefined &&
-      [...prepared.projects.values()].some(
-        (p) =>
-          inScope.has(p.name) && options.tasks.some((t) => declaredTask(p.config, t) !== undefined),
-      )
-    log.status(
-      reachedNone
-        ? `Nothing affected: the change reaches no ${options.tasks.join(', ')} task.`
-        : `No affected project declares task(s): ${options.tasks.join(', ')}.`,
-    )
+    log.status(noneAffected(prepared, options))
     await teardown()
     prepared.cache.close()
     return { ok: true, outcomes: [] }
@@ -1516,6 +1503,22 @@ async function applyCacheRetention(prepared: PreparedRun): Promise<void> {
   }
 }
 
+/** Why an `--affected` run has nothing to run, said alike by the run and its `--dry` plan. */
+function noneAffected(prepared: PreparedRun, options: RunOptions): string {
+  // A changed project declares the task, so `--affected`'s task walk is
+  // what left nothing (affected-tasks.ts), not the scope.
+  const inScope = new Set(options.projects ?? [])
+  const reachedNone =
+    options.affected !== undefined &&
+    [...prepared.projects.values()].some(
+      (p) =>
+        inScope.has(p.name) && options.tasks.some((t) => declaredTask(p.config, t) !== undefined),
+    )
+  return reachedNone
+    ? `Nothing affected: the change reaches no ${options.tasks.join(', ')} task.`
+    : `No affected project declares task(s): ${options.tasks.join(', ')}.`
+}
+
 /**
  * Planning mode. Same setup as `run()` — workspace discovery, config
  * load, package graph, task graph — but stops short of execution.
@@ -1548,6 +1551,8 @@ export async function planRun(options: RunOptions): Promise<RunPlan> {
         unresolvedHint: elsewhereHint(prepared.declaredElsewhere),
       }
     }
+    if (prepared.empty === 'none-affected')
+      return { tasks: [], noneAffected: noneAffected(prepared, options) }
     if (prepared.empty !== null) return { tasks: [] }
     // Its own mark: a dry run's plan (every task's hash, the cache lookups,
     // the history p50s) was booked under `close`, the next mark, and read