@vzn/vx 0.0.27 → 0.0.29

package/package.json

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

package/src/exec/executor.ts

@@ -254,15 +254,26 @@ export function assertExecuteResult(
  * Place one task: the first executor, in declaration order, that may take
  * it — a `remote` executor is skipped for a `pinnedLocal` task, then
  * `accepts()` decides. Decided once per task before scheduling. The local
- * executor accepts everything, so with it declared this cannot throw.
+ * executor accepts everything, so with it declared the only throw is an
+ * `accepts()` that threw: refused as `label` names that executor, where it
+ * surfaced as a bare stack naming no plugin (item 1022).
  */
 export function selectExecutor(
   executors: readonly TaskExecutor[],
   task: TaskPlacement,
+  label: (executor: TaskExecutor) => string = (e) => `executor '${e.name}'`,
 ): TaskExecutor {
   for (const executor of executors) {
     if (task.pinnedLocal && executor.remote === true) continue
-    if (executor.accepts === undefined || executor.accepts(task)) return executor
+    if (executor.accepts === undefined) return executor
+    let taken: boolean
+    try {
+      taken = executor.accepts(task)
+    } catch (err) {
+      const m = err instanceof Error ? err.message : String(err)
+      throw new UserError(`${label(executor)} failed in accepts for ${task.taskId}: ${m}`)
+    }
+    if (taken) return executor
   }
   throw new Error(
     `no executor accepted ${task.taskId} (declared: ${executors.map((e) => e.name).join(', ')}). Core's local executor accepts every task, so this means it is missing from the list.`,

package/src/orchestrator/placement.ts

@@ -10,7 +10,7 @@ import { selectExecutor, type TaskExecutor } from '../exec/index.js'
 import { isGroupTask, type TaskNode } from '../graph/index.js'
 import { resolveDownloadModes } from './download-policy.js'
 import type { Logger } from './logger.js'
-import { resolveExecutors } from './plugin-host.js'
+import { executorLabel, resolveExecutors } from './plugin-host.js'
 import type { prepareRun } from './prepare.js'
 
 /**
@@ -100,14 +100,18 @@ export function placeTasks(
   }
   for (const node of nodes.values()) {
     if (isGroupTask(node) || node.config.exec?.persistent !== undefined) continue
-    const executor = selectExecutor(executors, {
-      taskId: node.id,
-      projectName: node.projectName,
-      projectDir: node.projectDir,
-      command: node.config.exec!.command,
-      pinnedLocal: pinned.has(node.id),
-      cacheable: node.config.cache !== undefined,
-    })
+    const executor = selectExecutor(
+      executors,
+      {
+        taskId: node.id,
+        projectName: node.projectName,
+        projectDir: node.projectDir,
+        command: node.config.exec!.command,
+        pinnedLocal: pinned.has(node.id),
+        cacheable: node.config.cache !== undefined,
+      },
+      executorLabel,
+    )
     placements.executors.set(node.id, executor)
     if (node.config.exec?.remote === 'only') {
       // A pinned 'only' task (it transitively depends on a persistent one)

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)
@@ -364,6 +375,17 @@ export async function resolveCache(
   })
 }
 
+/** The plugin each resolved executor came from, so a hook of it that throws is named. */
+const executorPlugin = new WeakMap<TaskExecutor, string>()
+
+/** How a message names `executor`: its plugin and its own name, or its name alone (the floor). */
+export function executorLabel(executor: TaskExecutor): string {
+  const plugin = executorPlugin.get(executor)
+  return plugin === undefined
+    ? `executor '${executor.name}'`
+    : `plugin '${plugin}' (executor '${executor.name}')`
+}
+
 /**
  * Collect every plugin's `executor`, in declaration order, with core's
  * own appended at the tail: per task, `selectExecutor` takes the first
@@ -383,6 +405,7 @@ export async function resolveExecutors(
     if (typeof executor.name !== 'string' || executor.name.length === 0) {
       throw new UserError(`plugin '${plugin.name}' returned an executor with no name`)
     }
+    executorPlugin.set(executor, plugin.name)
     executors.push(executor)
   }
   // Core's own executor is the TAIL of every list, so a plugin executor

package/src/orchestrator/run.ts

@@ -40,7 +40,7 @@ import { excludedTaint } from './excluded-keys.js'
 import { keyUpstream } from './upstream.js'
 import { busLogger, createEventBus, terminalSubscriber, type EventBus } from './events.js'
 import { installPlugins, PluginSetupError } from './plugin.js'
-import { buildAdmission, resolveExecutors, teardownPlugins } from './plugin-host.js'
+import { buildAdmission, executorLabel, resolveExecutors, teardownPlugins } from './plugin-host.js'
 import { subscribeTelemetry, type TelemetryHandle } from './telemetry-host.js'
 import { assembleRunSummary, isPassStatus } from './telemetry.js'
 import type { RunContextRecord } from './telemetry.js'
@@ -364,16 +364,26 @@ async function runOnBus(
     remaining.add(id)
   }
   // The SAME set is handed back every time, narrowed in place: a consumer
-  // reading it later sees the truth rather than a stale snapshot.
-  await abandoning(() => {
-    for (const [executor, remaining] of demandOf) executor.demand!(remaining)
-  })
+  // reading it later sees the truth rather than a stale snapshot. A hint,
+  // as `admit` is: one that throws is named once and asked no more, where
+  // it surfaced as a bare stack, or mid-run from the completion path
+  // (item 1022).
+  const tellDemand = (executor: TaskExecutor, remaining: ReadonlySet<string>): void => {
+    try {
+      executor.demand!(remaining)
+    } catch (err) {
+      demandOf.delete(executor)
+      const m = err instanceof Error ? err.message : String(err)
+      log.status(`[vx] ${executorLabel(executor)} failed in demand: ${m}; not asked again this run`)
+    }
+  }
+  for (const [executor, remaining] of demandOf) tellDemand(executor, remaining)
   const narrowDemand =
     demandOf.size === 0
       ? (): void => {}
       : (id: string): void => {
           for (const [executor, remaining] of demandOf) {
-            if (remaining.delete(id)) executor.demand!(remaining)
+            if (remaining.delete(id)) tellDemand(executor, remaining)
           }
         }