@vzn/vx 0.0.515 → 0.0.516

package/package.json

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

package/src/graph/scheduler.ts

@@ -139,6 +139,11 @@ export interface TaskOutcome {
    * flaky detection reads it off the outcome stream.
    */
   attempts?: number
+  /**
+   * Set when this run proved the task flaky: its key holds both outcomes on
+   * record (this run's included) or it needed a retry. Its row carries it.
+   */
+  flaky?: { passes: number; failures: number }
   /**
    * Count of sandbox violations captured during this task's exec (a task
    * declaring `exec.sandbox`). Non-zero means the task touched something

package/src/orchestrator/events.ts

@@ -291,8 +291,7 @@ export function outcomeLabel(
 
 /**
  * Why a task was skipped, one copy for every surface: `blocked by lib#build`
- * (the failed or aborted task at the root of the block, what the footer's
- * Skipped section groups by), or '' for fail-fast's skip — the run stopped,
+ * (the failed or aborted task at the root of the block), or '' for fail-fast's skip — the run stopped,
  * nothing blocked it, and a label claiming an upstream failure would lie.
  */
 export function skippedReason(blockedBy: string | undefined): string {

package/src/orchestrator/framed-output.ts

@@ -344,22 +344,42 @@ function formatOutcomeRow(
 ): string {
   const st = statusOf(o)
   const ca = cacheOf(o)
-  return formatTaskRow(
-    taskGlyph(o, colors),
-    ms,
-    st.word,
-    st.color,
-    ca.word,
-    ca.color,
-    paintedId,
-    colors,
+  return (
+    formatTaskRow(
+      taskGlyph(o, colors),
+      ms,
+      st.word,
+      st.color,
+      ca.word,
+      ca.color,
+      paintedId,
+      colors,
+    ) + flakyNote(o, colors)
   )
 }
 
+/**
+ * The dim note a flaky task's row and frame carry (`flaky - failed 1×
+ * before`): nothing prints below the footer, so the task's own line is
+ * where the reader learns it. '' when the run did not prove it flaky.
+ */
+export function flakyNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): string {
+  if (o.flaky === undefined) return ''
+  const said: string[] = []
+  if (o.status === 'failed' && o.flaky.passes > 0)
+    said.push(`passed ${o.flaky.passes}\u00d7 before`)
+  if (o.status !== 'failed' && o.flaky.failures > 0) {
+    said.push(`failed ${o.flaky.failures}\u00d7 before`)
+  }
+  if ((o.attempts ?? 1) > 1) said.push(`${o.attempts} attempts`)
+  const text = said.length === 0 ? 'flaky' : `flaky - ${said.join(' \u00b7 ')}`
+  return ` ${paint('', text, colors, { dim: true })}`
+}
+
 /**
  * Compact one-liner for a skipped task — it never ran (blank time). The
- * blocker rides the row (`• blocked by lib#build`): the footer's Skipped
- * section groups the same fact, but the row is where the reader's eye is.
+ * blocker rides the row (`• blocked by lib#build`): nothing prints below
+ * the footer, so the row is where the reader learns what blocked it.
  */
 export function formatTaskSkippedLine(
   node: TaskNode,
@@ -564,7 +584,7 @@ function formatBlockFooter(o: TaskOutcome, colors: ColorSupport): string {
   // formatStatusTag.
   const dur = paint('', `(${formatDuration(o.durationMs)})`, colors, { dim: true })
   const tag = formatStatusTag(o, colors)
-  return ` ${dur} ${tag}`
+  return ` ${dur} ${tag}${flakyNote(o, colors)}`
 }
 
 function formatStatusTag(o: TaskOutcome, colors: ColorSupport): string {

package/src/orchestrator/logger.ts

@@ -8,6 +8,7 @@ import {
   formatTaskAbortedLine,
   formatTaskBlock,
   formatTaskExecutedLine,
+  flakyNote,
   formatTaskHitLine,
   formatTaskSkippedLine,
 } from './framed-output.js'
@@ -431,6 +432,10 @@ export function defaultLogger(
     (framesTerminal && holdsTerminal(node)) ||
     (view.mode === 'focused' && isPrimary(node) && !isGroupTask(node) && requestedCount <= 1)
 
+  const failureRow = (node: TaskNode, outcome: TaskOutcome): string =>
+    formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)) +
+    flakyNote(outcome, colors)
+
   return {
     settle() {
       // The bus delivers one `run:end`, so the CLI's last word reaches here.
@@ -697,25 +702,31 @@ export function defaultLogger(
           return
         }
         case 'errors-only':
+          if (outcome.status === 'skipped') {
+            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
+            return
+          }
           if (outcome.status !== 'failed') return
-          emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
+          emitLine(failureRow(node, outcome))
           deferredFailures.push(
             formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
           )
           return
         case 'broad':
-          // News only: executed work gets a one-liner, failures get
-          // the full frame. Hits (including up-to-date) are silent —
+          // News only: executed work and skips get a one-liner, failures
+          // get the full frame. Hits (including up-to-date) are silent —
           // their replay buffers are deliberately dropped; the counts
           // surface in the end-of-run summary.
           if (outcome.status === 'failed') {
             // ◼ row now; the full frame replays at runEnd.
-            emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
+            emitLine(failureRow(node, outcome))
             deferredFailures.push(
               formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
             )
           } else if (outcome.status === 'success') {
             emitLine(formatTaskExecutedLine(node, outcome, colors))
+          } else if (outcome.status === 'skipped') {
+            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
           }
           return
         case 'focused':
@@ -745,7 +756,7 @@ export function defaultLogger(
             // to runEnd like everywhere else; everything else emits
             // ONE atomic block from the buffered output.
             if (outcome.status === 'failed') {
-              emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
+              emitLine(failureRow(node, outcome))
               deferredFailures.push(
                 formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
               )
@@ -756,10 +767,12 @@ export function defaultLogger(
             emitBlock(formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors, true))
             return
           }
-          // Dependency-pulled nodes: silent on success; failures get
-          // the ◼ row now and their frame replayed at runEnd.
-          if (outcome.status === 'failed') {
-            emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
+          // Dependency-pulled nodes: silent on success; a skip gets its
+          // row, failures the ◼ row now and their frame replayed at runEnd.
+          if (outcome.status === 'skipped') {
+            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
+          } else if (outcome.status === 'failed') {
+            emitLine(failureRow(node, outcome))
             deferredFailures.push(
               formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
             )

package/src/orchestrator/run-artifacts.ts

@@ -33,7 +33,7 @@ export interface SummarizeArgs {
   /** The process's exit code where it is not `ok ? 0 : 1`: a stopping signal's. */
   exitCode?: number
   outcomes: readonly TaskOutcome[]
-  /** What `detectFlaky` found this run; the footer's Flaky section, typed. */
+  /** What `detectFlaky` found this run; each row's flaky note, typed. */
   flaky?: readonly FlakyFinding[]
 }
 

package/src/orchestrator/run.ts

@@ -90,8 +90,8 @@ 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 { formatFlakySection, formatRunSummary, formatSkippedSection } from './summary.js'
-import { detectFlaky, type FlakyCandidate } from './failure-mode.js'
+import { formatRunSummary } from './summary.js'
+import { detectFlaky, type FlakyCandidate, type FlakyFinding } from './failure-mode.js'
 import type { RunOptions, RunSummary } from './options.js'
 
 // Per run, never shared: a `vx watch` process runs many, and a shared map
@@ -973,6 +973,24 @@ async function runOnBus(
     })
 
     mark('classify + probe')
+    // Judged as each task finishes, against the history BEFORE this run's
+    // rows land, so the row that prints next carries the verdict: nothing
+    // prints below the footer. A hit or a skip asks nothing; a green miss
+    // is one probe of the failed-row index.
+    const flaky: FlakyFinding[] = []
+    const historyDb = prepared.localCache.dbHandle()
+    const judgeFlaky = (o: TaskOutcome): void => {
+      const candidates = flakyCandidates([o])
+      if (candidates.length === 0) return
+      try {
+        const found = detectFlaky(historyDb, candidates)[0]
+        if (found === undefined) return
+        flaky.push(found)
+        o.flaky = { passes: found.passes, failures: found.failures }
+      } catch {
+        // History is observability: an unreadable one judges nothing.
+      }
+    }
     const outcomes = await runGraph({
       nodes,
       concurrency,
@@ -988,6 +1006,7 @@ async function runOnBus(
       },
       onFinish: (o) => {
         taint.settled(o)
+        judgeFlaky(o)
         log.taskComplete(o.node, o)
         narrowDemand(o.node.id)
       },
@@ -1069,9 +1088,8 @@ async function runOnBus(
     if (stillUp.length > 0) {
       for (const line of formatPersistentList(stillUp, colors)) log.status(line)
     }
-    for (const line of formatRunSummary(list, totalMs, colors, runContext)) log.status(line)
     // A dependency-only server that died before the end of the graph
-    // stopped it: the footer counts it failed, this says why.
+    // stopped it: the footer below 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
     // 1102).
@@ -1079,20 +1097,11 @@ async function runOnBus(
       const code = typeof c.code === 'number' ? c.code : signalExitCode(c.code)
       log.status(`vx: ${c.id} exited with code ${code} before the run stopped it`)
     }
-    // The footer's "N skipped" names no task; this names each under the
-    // failure that blocked it.
-    for (const line of formatSkippedSection(list)) log.status(line)
-    // Judged against the history BEFORE this run's rows land, so the query
-    // is one scan over the executed tasks' keys and nothing at all on a run
-    // that executed none (every hit, every skip).
-    const flaky = detectFlaky(prepared.localCache.dbHandle(), flakyCandidates(list))
-    for (const line of formatFlakySection(flaky)) log.status(line)
     // Outputs that never came home are not an error, but a silent `dist/`
     // that is empty-or-stale would be: name every task whose bytes are
     // still remote.
     const stillDeferred = deferredOutputs.pending()
     if (stillDeferred.length > 0) {
-      log.status('')
       log.status(
         `  Deferred: ${stillDeferred.length} task(s) left outputs remote (--download=none): ${stillDeferred.join(', ')}`,
       )
@@ -1104,6 +1113,9 @@ async function runOnBus(
     // Ctrl-C there is the process's exit, and the first write said ok.
     const summarize = async (runOk: boolean, final = list): Promise<void> => {
       if (options.summarize === undefined) return
+      // The rewrite after the keep-alive wait says nothing: the footer is
+      // the run's last word.
+      const quiet = final !== list
       try {
         const wrote = await writeRunSummary({
           target: options.summarize,
@@ -1118,7 +1130,7 @@ async function runOnBus(
           outcomes: final,
           flaky,
         })
-        log.status(`vx: summary written to ${wrote}`)
+        if (!quiet) log.status(`vx: summary written to ${wrote}`)
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err)
         log.status(`vx: failed to write summary: ${msg}`)
@@ -1138,6 +1150,9 @@ async function runOnBus(
         log.status(`vx: failed to write profile: ${msg}`)
       }
     }
+    // The footer is the run's last word: every line above, nothing below
+    // (owner, 2026-10-06). A task's own facts (flaky, blocked) ride its row.
+    for (const line of formatRunSummary(list, totalMs, colors, runContext)) log.status(line)
 
     // Record each task to the run history in a single SQLite transaction
     // (one fsync instead of N), with the invocation header row alongside,

package/src/orchestrator/summary.ts

@@ -4,7 +4,6 @@
 // aren't real work and would inflate "N total" misleadingly.
 
 import type { TaskOutcome } from '../graph/index.js'
-import type { FlakyFinding } from './failure-mode.js'
 import { paint, type ColorSupport } from './colors.js'
 import { tallyOutcomes } from './tally.js'
 import { isGroupTask } from '../graph/index.js'
@@ -386,84 +385,6 @@ export function neverStarted(o: TaskOutcome): boolean {
   return o.status === 'aborted' && o.wallclockStartNs === undefined
 }
 
-/**
- * Post-summary section naming the tasks that never started, under the
- * failure that blocked them. The footer's "1 skipped" says a task was
- * blocked and nothing about which task or by what; the broad flow prints
- * no row for a skipped task on purpose (a wide red run would drown in
- * them), so this is where the reader learns what the failure cost
- * (item 266). The scheduler records the root of each block on the outcome
- * (`blockedBy`, item 267); a skip without one is fail-fast's. Empty when
- * nothing was skipped.
- */
-export function formatSkippedSection(outcomes: readonly TaskOutcome[]): string[] {
-  // A group (no `exec`) never starts by definition and is not a task the
-  // tally counts; listing a blocked one here named three "tasks" the legend
-  // beside it counted as none (item 281). Its members' rows say enough.
-  const skipped = outcomes.filter((o) => o.status === 'skipped' && !isGroupTask(o.node))
-  if (skipped.length === 0) return []
-  const byId = new Map(outcomes.map((o) => [o.node.id, o]))
-  const causeOf = (o: TaskOutcome): string => {
-    if (o.blockedBy === undefined) return 'after the run stopped (fail-fast)'
-    const root = byId.get(o.blockedBy)
-    return root?.status === 'aborted'
-      ? `after ${o.blockedBy} was aborted`
-      : `after ${o.blockedBy} failed`
-  }
-  const groups = new Map<string, string[]>()
-  for (const o of skipped) {
-    const cause = causeOf(o)
-    const list = groups.get(cause) ?? []
-    list.push(o.node.id)
-    groups.set(cause, list)
-  }
-  // "Blocked upstream" only when every skip was: a fail-fast skip had no
-  // blocker, and the header claimed one over its own cause line (C-55).
-  const blocked = skipped.every((o) => o.blockedBy !== undefined) ? ' \u2014 blocked upstream' : ''
-  const lines = [
-    '',
-    `  Skipped:  ${skipped.length} task${skipped.length === 1 ? '' : 's'} never started${blocked}`,
-  ]
-  const NAMES = 8
-  for (const [cause, ids] of [...groups].sort((a, b) => b[1].length - a[1].length)) {
-    ids.sort()
-    const shown = ids.slice(0, NAMES).join(', ')
-    const more = ids.length > NAMES ? ` \u2026 +${ids.length - NAMES} more` : ''
-    lines.push(`    \u2298 ${cause}: ${shown}${more}`)
-  }
-  return lines
-}
-
-/**
- * Post-summary section naming the tasks this run proved flaky: identical
- * inputs, both outcomes on record (or a retry within the run). A red run
- * whose failure has passed on these exact inputs before is not a break to
- * bisect, and a green run that only passed on the second attempt is not
- * green — either way the footer's counts alone would say nothing. Empty
- * when nothing was.
- */
-export function formatFlakySection(findings: readonly FlakyFinding[]): string[] {
-  if (findings.length === 0) return []
-  const lines = [
-    '',
-    `  Flaky:    ${findings.length} task${findings.length === 1 ? '' : 's'} with the same inputs both passing and failing on record`,
-  ]
-  for (const f of findings) {
-    const times = (n: number): string => `${n}\u00d7`
-    const history =
-      f.status === 'failed'
-        ? `failed on inputs that passed ${times(f.passes)} before`
-        : f.failures > 0
-          ? `passed on inputs that failed ${times(f.failures)} before`
-          : 'passed'
-    const retried = f.attempts > 1 ? ` \u00b7 ${f.attempts} attempts this run` : ''
-    lines.push(
-      `    ${f.status === 'failed' ? '\u2717' : '\u2713'} ${f.taskId} \u2014 ${history}${retried}`,
-    )
-  }
-  return lines
-}
-
 export function formatDuration(ms: number): string {
   return formatElapsed(ms)
 }