@vzn/vx 0.0.548 → 0.0.550

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.548",
+  "version": "0.0.550",
   "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.548",
-    "@vzn/vx-linux-arm64": "0.0.548",
-    "@vzn/vx-darwin-x64": "0.0.548",
-    "@vzn/vx-darwin-arm64": "0.0.548"
+    "@vzn/vx-linux-x64": "0.0.550",
+    "@vzn/vx-linux-arm64": "0.0.550",
+    "@vzn/vx-darwin-x64": "0.0.550",
+    "@vzn/vx-darwin-arm64": "0.0.550"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/orchestrator/doctor.ts

@@ -23,16 +23,19 @@ import {
   computeWorkspaceFingerprint,
   findWorkspaceRoot,
   type LoadReads,
-  loadProjectConfig,
   loadWorkspace,
   lockfilePath,
-  type ProjectMeta,
   resolveCacheDir,
   resolveStoreRoot,
 } from '../workspace/index.js'
 import { flakyTasks, type FlakyTask } from './failure-mode.js'
 import type { VxPlugin } from './plugin.js'
-import { discoverProjects, loadProjects, loadWorkspacePlugins } from './projects.js'
+import {
+  discoverProjects,
+  type LoadProjectsArgs,
+  loadProjects,
+  loadWorkspacePlugins,
+} from './projects.js'
 
 const warnToStderr = (message: string): void => {
   process.stderr.write(`${message}\n`)
@@ -167,23 +170,23 @@ async function collectWorkspaceInfo(
     // The run path's load — a plugin's `project` stage counts — so the
     // doctor's task count is the number a run would see. A broken config
     // must not take the doctor down with it: the count then falls back to
-    // the configs that do load, one by one, the broken ones as zero.
-    try {
-      const loaded = await loadProjects({
+    // the same load, one project at a time, the broken ones as zero.
+    const load = {
+      workspaceRoot: root,
+      cacheDir,
+      plugins,
+      projectMetas: metas,
+      closure: false,
+      lock: null,
+      evalCache: {
+        store: cache,
         workspaceRoot: root,
-        cacheDir,
-        plugins,
-        projectMetas: metas,
-        seeds: 'all',
-        closure: false,
-        lock: null,
-        evalCache: {
-          store: cache,
-          workspaceRoot: root,
-          workspaceFingerprint: await computeWorkspaceFingerprint(root, reads),
-        },
-        warn,
-      })
+        workspaceFingerprint: await computeWorkspaceFingerprint(root, reads),
+      },
+      warn,
+    } as const
+    try {
+      const loaded = await loadProjects({ ...load, seeds: 'all' })
       for (const p of loaded.projects.values()) {
         const tasks = p.config.tasks ?? {}
         taskCount += Object.keys(tasks).length
@@ -197,7 +200,7 @@ async function collectWorkspaceInfo(
         tasks: taskCount,
         sandboxed,
         errors: configErrors,
-      } = await countLoadableTasks(metas, root))
+      } = await countLoadableTasks(load, root))
     }
   } finally {
     cache.close()
@@ -362,18 +365,19 @@ function gitVersion(): string | null {
 }
 
 async function countLoadableTasks(
-  metas: readonly ProjectMeta[],
+  load: Omit<LoadProjectsArgs, 'seeds'> & { closure: false },
   root: string,
 ): Promise<{ tasks: number; sandboxed: number; errors: InfoFacts['configErrors'] }> {
   let tasks = 0
   let sandboxed = 0
   const errors: InfoFacts['configErrors'] = []
+  // No seeds loads nothing and answers which projects an 'all' load seeds.
+  const { configured } = await loadProjects({ ...load, seeds: [] })
   await Promise.all(
-    metas.map(async (meta) => {
-      if (meta.configPath === null) return
+    configured.map(async (meta) => {
       try {
-        const config = await loadProjectConfig(meta.configPath)
-        const declared = Object.values(config.tasks ?? {})
+        const loaded = await loadProjects({ ...load, seeds: [meta.name] })
+        const declared = Object.values(loaded.projects.get(meta.name)?.config.tasks ?? {})
         tasks += declared.length
         for (const t of declared) if (t?.exec?.sandbox !== undefined) sandboxed++
       } catch (err) {
@@ -385,11 +389,12 @@ async function countLoadableTasks(
         // still did).
         const raw = err instanceof Error ? err.message : String(err)
         const bare = raw.startsWith('Project config ') ? raw.slice('Project config '.length) : raw
-        const message = bare.startsWith(`${meta.configPath}:`)
-          ? bare.slice(meta.configPath.length + 1).trimStart()
+        const where = meta.configPath ?? meta.dir
+        const message = bare.startsWith(`${where}:`)
+          ? bare.slice(where.length + 1).trimStart()
           : raw
         errors.push({
-          path: path.relative(root, meta.configPath).split(path.sep).join('/'),
+          path: path.relative(root, where).split(path.sep).join('/'),
           message,
         })
       }

package/src/orchestrator/run-report.ts

@@ -10,6 +10,7 @@
 // too. `--report-file` is the sink that carries the property end to end.
 
 import { failedLabel, skippedLabel, type OutcomeView } from './events.js'
+import { neverStarted } from './summary.js'
 
 /**
  * One finished run, reduced to what a report needs. Used to live in
@@ -35,8 +36,10 @@ import { tallyViews, type Tally } from './tally.js'
  * a row claiming `success | miss | 0ms`.
  */
 interface ReportTally extends Tally {
-  /** Wall-clock ms summed over tasks that actually executed (misses). */
+  /** Wall-clock ms summed over tasks that ran a command, an aborted one's time so far included. */
   executedMs: number
+  /** The aborted tasks the stop reached before they ran, as the terminal splits them. */
+  notRun: number
   /**
    * Ms of work the cache SKIPPED — the sum of the hits' STORED exec times.
    * Deliberately not `durationMs`, which for a hit is the restore this run
@@ -46,7 +49,7 @@ interface ReportTally extends Tally {
 }
 
 function tally(outcomes: readonly OutcomeView[]): ReportTally {
-  const t: ReportTally = { ...tallyViews(outcomes), executedMs: 0, savedMs: 0 }
+  const t: ReportTally = { ...tallyViews(outcomes), executedMs: 0, savedMs: 0, notRun: 0 }
   for (const o of outcomes) {
     if (o.isGroup === true) continue
     switch (o.status) {
@@ -54,6 +57,10 @@ function tally(outcomes: readonly OutcomeView[]): ReportTally {
       case 'failed':
         t.executedMs += o.durationMs
         break
+      case 'aborted':
+        if (neverStarted(o)) t.notRun++
+        else t.executedMs += o.durationMs
+        break
       case 'cache-hit':
       case 'cache-hit-remote':
         // An outcome that doesn't know what it skipped contributes nothing:
@@ -78,6 +85,8 @@ function statusWord(o: OutcomeView): string {
       return failedLabel(o.exitCode, o.timedOut, o.sandboxViolations, o.notReady)
     case 'skipped':
       return skippedLabel(o.blockedBy)
+    case 'aborted':
+      return neverStarted(o) ? 'not run' : 'aborted'
     default:
       return o.status
   }
@@ -145,12 +154,21 @@ export function formatRunReportMarkdown(result: RunResult): string {
       : '0 cached',
   ]
   if (t.skipped > 0) parts.push(`${t.skipped} skipped`)
-  if (t.aborted > 0) parts.push(`${t.aborted} aborted`)
   parts.push(`${fmtDuration(t.executedMs)} total`)
   if (t.savedMs > 0) parts.push(`${fmtDuration(t.savedMs)} saved`)
+  // The terminal summary's words: neither is in `total`, and a task the stop
+  // reached before it ran was never aborted.
+  const aborted = t.aborted - t.notRun
+  const uncounted: string[] = []
+  if (aborted > 0) uncounted.push(`${aborted} aborted`)
+  if (t.notRun > 0) uncounted.push(`${t.notRun} not run`)
+  if (uncounted.length > 0) parts.push(`not counted: ${uncounted.join(', ')}`)
 
+  // Only a stop (a signal, `RunOptions.signal`) makes an `aborted` outcome,
+  // so one is how an interrupted run tells itself from a failed one.
+  const heading = t.aborted > 0 ? 'interrupted' : result.ok ? 'passed' : 'failed'
   const lines: string[] = []
-  lines.push(`## vx run — ${result.ok ? 'passed' : 'failed'}`)
+  lines.push(`## vx run — ${heading}`)
   lines.push('')
   lines.push(parts.join(' · '))
   lines.push('')
@@ -163,7 +181,7 @@ export function formatRunReportMarkdown(result: RunResult): string {
     if (o.isGroup === true) continue
     lines.push(
       `| ${cell(o.taskId)} | ${cell(statusWord(o))} | ${cell(cacheWord(o))} | ${cell(
-        fmtDuration(o.durationMs),
+        neverStarted(o) ? '—' : fmtDuration(o.durationMs),
       )} |`,
     )
   }

package/src/orchestrator/summary.ts

@@ -381,7 +381,9 @@ export function formatRunSummary(
  * it an invented exit 1; only a started task carries a wall-clock start, so
  * that is what tells "never ran" from "killed" (item 1062).
  */
-export function neverStarted(o: TaskOutcome): boolean {
+export function neverStarted(
+  o: Pick<TaskOutcome, 'status'> & { wallclockStartNs?: unknown },
+): boolean {
   return o.status === 'aborted' && o.wallclockStartNs === undefined
 }
 

package/src/workspace/config-eval.ts

@@ -175,7 +175,14 @@ self.onmessage = async (e) => {
       fn: typeof mod === 'function',
       changed: report,
     })
-  } catch (err) {
+  } catch (thrown) {
+    // Two syntax errors arrive as one AggregateError, whose own message
+    // names no line; the in-process load reports the first (X-6), so the
+    // hop does too (X-26).
+    const err =
+      thrown?.name === 'AggregateError' && Array.isArray(thrown.errors) && thrown.errors.length > 0
+        ? thrown.errors[0]
+        : thrown
     const report = changed()
     umaskBack()
     postMessage({