@vzn/vx 0.0.498 → 0.0.499

package/package.json

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

package/src/orchestrator/framed-output.ts

@@ -28,7 +28,7 @@
 import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
 import { maskedCommand } from '../util/index.js'
 import { paint, type ColorSupport } from './colors.js'
-import { formatDuration } from './summary.js'
+import { formatDuration, neverStarted } from './summary.js'
 import { outcomeLabel, skippedReason } from './events.js'
 
 const NO_COLOR: ColorSupport = { enabled: false }
@@ -54,6 +54,7 @@ const TASK = '#f472b6' // pink-400 — task part of an id
 const SUCCESS = '#22c55e' // green-500 — success / fresh
 const WARN = '#eab308' // yellow-500 — skipped
 const ERROR = '#ef4444' // red-500 — failed
+const ABORTED = '#f97316' // orange-500 — killed by a shutdown signal
 const LOCAL = '#38bdf8' // sky-400 — local cache hit
 const REMOTE = '#2563eb' // blue-600 — remote cache hit
 
@@ -210,13 +211,13 @@ function paintTaskId(node: TaskNode, colors: ColorSupport, opts: { bold?: boolea
 
 // ── Reported-line grid: glyph · time · status · cache · name ────────
 // glyph SHAPE encodes the cache axis (⏺ miss · ► fresh · ⇢ local · ⇣
-// remote; ◼ failed · ⊘ skipped), glyph COLOR encodes the
+// remote; ◼ failed · ⊘ skipped · ✗ aborted · ◌ not run), glyph COLOR encodes the
 // task axis (green/red/yellow/cyan). The status and cache WORDS spell
 // the two axes out, each in its own color. Time is right-aligned in a
 // fixed cell so durations line up and a ticking elapsed never shifts
 // the row. All detail (exit code, output) lives in the framed block.
 export const TIME_COL = 7 // "0ms" … "999.99s"
-const STATUS_COL = 7 // "success" / "running" / "skipped"
+const STATUS_COL = 7 // "success" / "running" / "skipped" / "aborted" / "not run"
 const CACHE_COL = 8 // "no-cache" / "remote" / "local" / "fresh" / "miss"
 
 /** Right-align the duration in a TIME_COL cell (pad on the left). */
@@ -381,6 +382,41 @@ export function formatTaskSkippedLine(
   )
 }
 
+/**
+ * One row for a task a shutdown signal killed (`aborted`, its time so far)
+ * or one the stop reached before it ran (`not run`, no time). Neither
+ * reached the cache, so the cache cell is blank, as a skip's is.
+ */
+export function formatTaskAbortedLine(
+  node: TaskNode,
+  o: TaskOutcome,
+  colors: ColorSupport = NO_COLOR,
+): string {
+  const id = paintTaskId(node, colors)
+  if (neverStarted(o)) {
+    return formatTaskRow(
+      paint('', '\u25cc', colors, { dim: true }),
+      null,
+      'not run',
+      '',
+      '',
+      '',
+      id,
+      colors,
+    )
+  }
+  return formatTaskRow(
+    paint(ABORTED, '\u2717', colors),
+    o.durationMs,
+    'aborted',
+    ABORTED,
+    '',
+    '',
+    id,
+    colors,
+  )
+}
+
 /**
  * Live-frame brackets for focused mode: the requested task's output
  * streams raw between an opening line (id + command) and a closing

package/src/orchestrator/logger.ts

@@ -5,6 +5,7 @@ import {
   formatFrameOpen,
   formatKeptLines,
   formatPersistentTailBlock,
+  formatTaskAbortedLine,
   formatTaskBlock,
   formatTaskExecutedLine,
   formatTaskHitLine,
@@ -17,7 +18,7 @@ import {
   type StatusStream,
   type WorkerSlot,
 } from './status-line.js'
-import { formatDuration, formatSummarySection, type RunContext } from './summary.js'
+import { formatDuration, formatSummarySection, neverStarted, type RunContext } from './summary.js'
 import { isGroupTask } from '../graph/index.js'
 import { appendTail, createTail, resetTail, tailText, type Tail } from '../util/index.js'
 import { isCacheHit } from './telemetry.js'
@@ -583,9 +584,9 @@ export function defaultLogger(
       // The pre-ready window closed either way: a failed task is over, and
       // a ready one starts a fresh post-ready tail below.
       persistentTails.delete(node.id)
-      // An aborted task (child killed by a shutdown signal) reverts
-      // to pending: free its worker slot, but never count or render it
-      // — the run is tearing down and it has no honest outcome.
+      // An aborted task (killed by a shutdown signal, or reached by the stop
+      // before it ran) frees its worker slot but is never counted live: the
+      // run is tearing down and it has no honest outcome.
       if (outcome.status === 'aborted') {
         const si = slots.findIndex((s) => s !== null && s.id === node.id)
         if (si >= 0) slots[si] = slotQueue.shift() ?? null
@@ -594,24 +595,32 @@ export function defaultLogger(
           if (qi >= 0) slotQueue.splice(qi, 1)
         }
         refresh(true)
+        if (isGroupTask(node)) return
         // What it printed while it stopped (a trap's cleanup) still reaches
         // the terminal where a frame would have: a task that traps Ctrl-C
         // and exits 0 is aborted since item 962, and its frame was dropped
-        // with the count.
+        // with the count. A task that never started opened no frame.
         const framed =
-          view.mode === 'full' ||
-          (view.mode === 'focused' && isPrimary(node)) ||
-          (framesTerminal && holdsTerminal(node))
-        if (framed && !isGroupTask(node)) {
-          if (streamsLive(node)) {
-            if (streamMidLine) {
-              writer.write('\n')
-              streamMidLine = false
-            }
-            emitFrameClose(formatFrameClose(node, outcome, colors))
-          } else if (stdout.length > 0 || stderr.length > 0) {
-            emitBlock(formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors, true))
+          !neverStarted(outcome) &&
+          (view.mode === 'full' ||
+            (view.mode === 'focused' && isPrimary(node)) ||
+            (framesTerminal && holdsTerminal(node)))
+        if (framed && streamsLive(node)) {
+          if (streamMidLine) {
+            writer.write('\n')
+            streamMidLine = false
           }
+          emitFrameClose(formatFrameClose(node, outcome, colors))
+          return
+        }
+        if (framed && (stdout.length > 0 || stderr.length > 0)) {
+          emitBlock(formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors, true))
+          return
+        }
+        // Otherwise a row in the task list, in every view that lists a
+        // failure: the run exits red, and the row names why.
+        if (view.mode !== 'none' && view.mode !== 'hash-only') {
+          emitLine(formatTaskAbortedLine(node, outcome, colors))
         }
         return
       }

package/src/orchestrator/run.ts

@@ -90,12 +90,7 @@ import { assembleRunRecords } from './run-records.js'
 import { hasEnded, selectKeepAlive, shutdownPersistent } from './persistent.js'
 import { writeRunProfile, writeRunSummary } from './run-artifacts.js'
 import { createSaveLane } from './save-lane.js'
-import {
-  formatAbortedSection,
-  formatFlakySection,
-  formatRunSummary,
-  formatSkippedSection,
-} from './summary.js'
+import { formatFlakySection, formatRunSummary, formatSkippedSection } from './summary.js'
 import { detectFlaky, type FlakyCandidate } from './failure-mode.js'
 import type { RunOptions, RunSummary } from './options.js'
 
@@ -1063,10 +1058,7 @@ async function runOnBus(
       for (const line of formatPersistentList(stillUp, colors)) log.status(line)
     }
     for (const line of formatRunSummary(list, totalMs, colors, runContext)) log.status(line)
-    // A task killed by a shutdown signal is in no bucket above, yet it makes
-    // `ok` false — name it, or the red exit is undiagnosable.
-    for (const line of formatAbortedSection(list)) log.status(line)
-    // And a dependency-only server that died before the end of the graph
+    // A dependency-only server that died before the end of the graph
     // stopped it: the footer counts it failed, this says why.
     // A signal death is named as its exit code, as the keep-alive wait
     // names it: `code SIGTERM` read beside `code 143` for one event (item

package/src/orchestrator/summary.ts

@@ -19,6 +19,7 @@ const WARN = '#eab308'
 const LOCAL = '#38bdf8' // sky-400
 const REMOTE = '#2563eb' // blue-600
 const ERROR = '#ef4444'
+const ABORTED = '#f97316' // orange-500: red's neighbour, not a failure
 
 const BAR_WIDTH = 50
 // Brand gradient for the rule: identity violet → pink (the project /
@@ -99,6 +100,10 @@ export interface SummaryStats {
   /** Ended OK — executed successes AND cache hits. */
   successful: number
   skipped: number
+  /** Killed by a shutdown signal (final summary only). Not in `total`. */
+  aborted?: number
+  /** Reached by the stop before they ran (final summary only). Not in `total`. */
+  notRun?: number
   total: number
   upToDate: number
   restoredLocal: number
@@ -143,6 +148,8 @@ export function formatSummarySection(
   const miss = stats.miss
   const noCache = stats.noCache ?? 0
   const left = stats.left ?? 0
+  const aborted = stats.aborted ?? 0
+  const notRun = stats.notRun ?? 0
   const remainder = { n: left, color: '', glyph: '\u25b1', dim: true }
 
   const dim = (txt: string) => paint('', txt, colors, { dim: true })
@@ -157,6 +164,12 @@ export function formatSummarySection(
   if (stats.successful > 0) taskParts.push(paint(SUCCESS, `${stats.successful} success`, colors))
   if (stats.skipped > 0) taskParts.push(paint(WARN, `${stats.skipped} skipped`, colors))
   if (stats.total > 0) taskParts.push(dim(`${stats.total} total`))
+  // Rows in the task list, but outside `total`: history and telemetry count
+  // the same tasks the total does, and an aborted task did no work.
+  const uncounted: string[] = []
+  if (aborted > 0) uncounted.push(paint(ABORTED, `${aborted} aborted`, colors))
+  if (notRun > 0) uncounted.push(dim(`${notRun} not run`))
+  if (uncounted.length > 0) taskParts.push(`${dim('not counted:')} ${uncounted.join(dim(', '))}`)
   const taskBar = segmentBar(
     [
       { n: stats.failed, color: ERROR },
@@ -201,6 +214,8 @@ export function formatSummarySection(
     if (taskParts.length > 0) lines.push(legend(taskParts))
   } else {
     lines.push(row('tasks', dim('0 tasks')))
+    // A stop before any task finished still names what it took down.
+    if (taskParts.length > 0) lines.push(legend(taskParts))
   }
 
   // Cache meter + numbers, fixed order: miss · up-to-date · local ·
@@ -324,11 +339,14 @@ export function formatRunSummary(
     .filter((o) => (o.status === 'success' || o.status === 'failed') && !isGroupTask(o.node))
     .map((o) => o.durationMs)
   const heldOutcomes = outcomes.filter((o) => o.admissionHeldMs !== undefined)
+  const notRun = outcomes.filter((o) => neverStarted(o) && !isGroupTask(o.node)).length
   return formatSummarySection(
     {
       failed: t.failed,
       successful: t.successful,
       skipped: t.skipped,
+      aborted: t.aborted - notRun,
+      notRun,
       total: t.total,
       upToDate: t.upToDate,
       restoredLocal: t.restoredLocal,
@@ -360,35 +378,12 @@ export function formatRunSummary(
 }
 
 /**
- * Post-summary section naming the tasks a shutdown signal killed, and those
- * the stop reached before they ran. An aborted task did no work, so it is in
- * no tally bucket and no history row — but the run still exits non-zero, and
- * without this the user reads a red exit over a fully green summary that
- * names nothing. Empty when nothing aborted.
+ * An `aborted` outcome the stop reached before dispatch. The scheduler gives
+ * 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 formatAbortedSection(outcomes: readonly TaskOutcome[]): string[] {
-  // The scheduler marks what the stop reached before dispatch `aborted` too,
-  // with an invented exit 1: listed as killed, a task that never ran read as
-  // one the signal cut short (item 1062). Only a started one carries a
-  // wall-clock start. A group is no task here, as in the skipped section.
-  const aborted = outcomes.filter((o) => o.status === 'aborted' && !isGroupTask(o.node))
-  const killed = aborted.filter((o) => o.wallclockStartNs !== undefined)
-  const unstarted = aborted.filter((o) => o.wallclockStartNs === undefined)
-  const tasks = (n: number): string => `${n} task${n === 1 ? '' : 's'}`
-  const lines: string[] = []
-  if (killed.length > 0) {
-    lines.push(
-      '',
-      `  Aborted:  ${tasks(killed.length)} killed by a shutdown signal — not counted above`,
-    )
-    for (const o of killed) lines.push(`    ✗ ${o.node.id} — exit ${o.exitCode}, nothing cached`)
-  }
-  if (unstarted.length > 0) {
-    const they = unstarted.length === 1 ? 'it' : 'they'
-    lines.push('', `  Not started:  ${tasks(unstarted.length)} the run stopped before ${they} ran`)
-    for (const o of unstarted) lines.push(`    · ${o.node.id}`)
-  }
-  return lines
+export function neverStarted(o: TaskOutcome): boolean {
+  return o.status === 'aborted' && o.wallclockStartNs === undefined
 }
 
 /**