@vzn/vx 0.0.514 → 0.0.516

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.514",
+  "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.514",
-    "@vzn/vx-linux-arm64": "0.0.514",
-    "@vzn/vx-darwin-x64": "0.0.514",
-    "@vzn/vx-darwin-arm64": "0.0.514"
+    "@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/cache/cache.ts

@@ -37,6 +37,7 @@ import {
   closeSync,
   constants,
   existsSync,
+  linkSync,
   lstatSync,
   mkdirSync,
   openSync,
@@ -181,17 +182,23 @@ export function noteSchemaReset(cache: Cache, warn: (message: string) => void):
       `[vx] cache entries now live in the shared store ${to}; the ones in ${from} miss once, and \`vx cache prune\` reclaims their artifacts`,
     )
   }
+  if (cache.storeReset !== null) {
+    const { from, to } = cache.storeReset
+    warn(
+      `[vx] shared cache store ${cache.storeDir} re-indexed: schema ${from} → ${to} (vx version changed); its artifacts stay and are indexed again as tasks hit them`,
+    )
+  }
   if (cache.formatChange !== null) {
     const { from, to } = cache.formatChange
     warn(
-      `[vx] cache format changed: ${from} → ${to} (vx upgraded); every cached task misses once and re-saves, and the old entries, never read again, age out under \`vx cache prune --older-than\` or \`cacheRetention\``,
+      `[vx] cache format changed: ${from} → ${to} (vx version changed); every cached task misses once and re-saves, and the old entries, never read again, age out under \`vx cache prune --older-than\` or \`cacheRetention\``,
     )
     return
   }
   if (cache.schemaReset === null) return
   const { from, to } = cache.schemaReset
   warn(
-    `[vx] cache index reset: schema ${from} → ${to} (vx upgraded); every cached task misses once and re-saves, and \`vx cache prune\` reclaims the old artifacts`,
+    `[vx] cache index reset: schema ${from} → ${to} (vx version changed); run history starts over, and each artifact is indexed again when its task next hits`,
   )
 }
 // SCHEMA history (drop+recreate on mismatch; pre-alpha, no migrations):
@@ -269,12 +276,6 @@ const STORE_TABLES = ['entry_inputs', 'output_files', 'entry_stdout', 'store_met
 const SELECT_ENTRY =
   "SELECT e.*, COALESCE(s.stdout, '') AS stdout FROM entries e LEFT JOIN entry_stdout s ON s.hash = e.hash"
 
-/** A schema version's number (`v28` → 28); one that is not `v<n>` is older than any. */
-function schemaOrdinal(version: string): number {
-  const m = /^v(\d+)$/.exec(version)
-  return m === null ? -1 : Number(m[1])
-}
-
 /**
  * Artifacts `indexed` does not hold, and temps, past the in-flight grace
  * window: one readdir, one stat per candidate. `indexed` is asked only
@@ -574,6 +575,13 @@ export class Cache implements CacheLayer {
    */
   readonly formatChange: SchemaReset | null = null
 
+  /**
+   * Set when THIS open found the shared store written under another
+   * `SCHEMA_VERSION` and dropped its inventory; the artifacts stay and are
+   * indexed again as they hit. Reported by `noteSchemaReset`.
+   */
+  readonly storeReset: SchemaReset | null = null
+
   /** A reading verb's open: it never resets the index (the constructor's `mode`). */
   static inspect(cacheDir: string): Cache {
     return new Cache(cacheDir, undefined, undefined, undefined, 'inspect')
@@ -607,7 +615,7 @@ export class Cache implements CacheLayer {
     } catch {
       return null
     }
-    if (found === undefined || schemaOrdinal(found) >= schemaOrdinal(SCHEMA_VERSION)) return null
+    if (found === undefined || found === SCHEMA_VERSION) return null
     const aged = await scanOrphanFiles(cacheDir, () => new Set())
     let orphanBytes = 0
     for (const o of aged) orphanBytes += o.size
@@ -634,7 +642,7 @@ export class Cache implements CacheLayer {
     /**
      * The shared store's directory, unversioned: every key is seeded with
      * `CACHE_VERSION`, so two vx versions never read each other's entries,
-     * and a store table only ever gains columns (owner, 2026-10-06). Or
+     * and the store's own schema is `store_meta.schema` (`matchStoreSchema`). Or
      * `null` for an index that holds its entries itself (a `cacheDir`).
      * Undefined follows the layout the index records: a reading verb, a
      * plugin's handle.
@@ -744,20 +752,14 @@ export class Cache implements CacheLayer {
           | { value: string }
           | undefined
       )?.value
-    // Only an EARLIER schema is reset, and only by an opener that may write
-    // it. A newer one is another vx's index and history: an older binary
-    // (a global install beside a workspace's own) dropped every table of it
-    // and announced "vx upgraded", and so did a reading verb, a dry prune
-    // among them (item 896).
+    // Any other schema is reset by an opener that may write it: the index is
+    // an inventory the artifacts rebuild, whichever vx wrote it (owner,
+    // 2026-10-06; a newer one used to be refused, item 896). A reading verb
+    // leaves it as it was.
     const refuseUnreadable = (found: string): void => {
-      if (schemaOrdinal(found) > schemaOrdinal(SCHEMA_VERSION)) {
-        throw new UserError(
-          `the cache at ${cacheDir} holds index schema ${found}, written by a newer vx; this vx reads ${SCHEMA_VERSION} and leaves it untouched. Run the newer vx, or give this one another --cache-dir`,
-        )
-      }
       if (mode === 'inspect') {
         throw new UserError(
-          `the cache at ${cacheDir} holds index schema ${found} from an earlier vx; this vx reads ${SCHEMA_VERSION}, so nothing in it is readable here, and this verb leaves it untouched. The next \`vx run\` resets it`,
+          `the cache at ${cacheDir} holds index schema ${found} from another vx version; this vx reads ${SCHEMA_VERSION}, so nothing in it is readable here, and this verb leaves it untouched. The next \`vx run\` resets it`,
         )
       }
     }
@@ -850,9 +852,19 @@ export class Cache implements CacheLayer {
     }
     this.storeDir = storeDir
     this.artifactDir = storeDir ?? cacheDir
-    if (storeDir !== undefined) this.attachStore(storeDir, mode === 'inspect')
+    if (storeDir !== undefined) {
+      this.attachStore(storeDir, mode === 'inspect')
+      this.storeReset = this.matchStoreSchema(mode === 'open' && this.writeBlocked === null)
+    }
 
     createTables(this.db, storeDir === undefined ? 'main' : 'store')
+    if (storeDir !== undefined && mode === 'open' && this.writeBlocked === null) {
+      this.db
+        .prepare(
+          "INSERT INTO store.store_meta(key, value) VALUES ('schema', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+        )
+        .run(SCHEMA_VERSION)
+    }
     if (mode === 'open' && this.writeBlocked === null && storeDir !== recorded) {
       if (storeDir === undefined)
         this.db.prepare("DELETE FROM schema_meta WHERE key = 'store_dir'").run()
@@ -977,6 +989,57 @@ export class Cache implements CacheLayer {
     }
   }
 
+  /**
+   * The store is an inventory of the artifacts beside it, and only this vx
+   * reads it: a store another `SCHEMA_VERSION` wrote has its tables dropped
+   * (owner, 2026-10-06), the artifacts kept. Each is indexed again from its
+   * own bytes on its next hit (`adopt`). A reading verb reads such a store
+   * as empty and changes nothing.
+   */
+  private matchStoreSchema(writable: boolean): SchemaReset | null {
+    const tables = new Set(
+      (
+        this.db
+          .prepare("SELECT name FROM store.sqlite_master WHERE type = 'table'")
+          .all() as Array<{
+          name: string
+        }>
+      ).map((r) => r.name),
+    )
+    if (!tables.has('entries')) return null
+    const found = tables.has('store_meta')
+      ? (
+          this.db.prepare("SELECT value FROM store.store_meta WHERE key = 'schema'").get() as {
+            value: string
+          } | null
+        )?.value
+      : undefined
+    if (found === SCHEMA_VERSION) return null
+    if (!writable) {
+      this.db.exec('DETACH DATABASE store')
+      this.db.prepare('ATTACH DATABASE ? AS store').run(':memory:')
+      return null
+    }
+    let reset: SchemaReset | null = null
+    this.db
+      .transaction(() => {
+        // Re-read under the write lock: another workspace's open may have
+        // reset it first.
+        const now = (
+          this.db.prepare("SELECT value FROM store.store_meta WHERE key = 'schema'").get() as {
+            value: string
+          } | null
+        )?.value
+        if (now === SCHEMA_VERSION) return
+        for (const t of STORE_TABLES) {
+          if (t !== 'store_meta') this.db.exec(`DROP TABLE IF EXISTS store.${t}`)
+        }
+        reset = { from: found ?? 'an earlier schema', to: SCHEMA_VERSION }
+      })
+      .immediate()
+    return reset
+  }
+
   // --- config evaluations: `ConfigEvalStore`, delegated to `ConfigEvalTable` ---
   getConfigEval(key: string): string | null {
     return this.guard(() => this.configEvals.getConfigEval(key))
@@ -1107,11 +1170,53 @@ export class Cache implements CacheLayer {
   // ctx is accepted but ignored — the local layer reads metadata from
   // the entries row. It's part of the contract so LayeredCache can
   // route metadata to `ingest()` on remote-hit without a separate API.
-  async get(hash: string, _ctx?: CacheGetContext): Promise<CacheEntry | null> {
+  async get(hash: string, ctx?: CacheGetContext): Promise<CacheEntry | null> {
     // Local reads disabled (e.g. `--force` / `--cache=local:w`): report a
     // miss so the task re-executes. The artifact + index are untouched.
     if (!this.read) return null
-    return this.guard(() => this.readEntry(hash))
+    return this.guard(async () => {
+      const entry = await this.readEntry(hash)
+      if (entry !== null || ctx === undefined || !this.write) return entry
+      return (await this.adopt(hash, ctx)) ? this.readEntry(hash) : null
+    })
+  }
+
+  /**
+   * Index an artifact the index does not know, from its own bytes: the
+   * artifact is the record, the index only an inventory of it (owner,
+   * 2026-10-06). A reset index (a `SCHEMA_VERSION` change, a `cache.db` or
+   * `store.db` deleted) loses nothing a task asks for again. The artifact
+   * is checked as an ingest checks a remote's (its recorded key, its names
+   * against the declared outputs); one that fails is a miss, and the run
+   * that follows saves over it.
+   */
+  private async adopt(hash: string, ctx: CacheGetContext): Promise<boolean> {
+    const finalPath = this.tarPath(hash)
+    if (!existsSync(finalPath)) return false
+    const tmpPath = this.tempPath(hash)
+    try {
+      // A second name for the same bytes: the index step renames it over
+      // the artifact inside its write transaction, as for a save.
+      linkSync(finalPath, tmpPath)
+    } catch {
+      return false
+    }
+    try {
+      await this.writeArtifactAndIndex(
+        hash,
+        { tmpPath },
+        {
+          taskId: ctx.taskId,
+          command: ctx.command,
+          durationMs: 0,
+          ...(ctx.outputs !== undefined ? { outputs: ctx.outputs } : {}),
+        },
+      )
+      return true
+    } catch (err) {
+      if (err instanceof CorruptArtifactError || err instanceof ArchiveSecurityError) return false
+      throw err
+    }
   }
 
   /**
@@ -1160,8 +1265,21 @@ export class Cache implements CacheLayer {
    * The up-front short-circuit probe is the caller; per-hit `get` stays for
    * the lazy path.
    */
-  async getMany(hashes: readonly string[]): Promise<Map<string, CacheEntry>> {
-    return this.guard(() => this.getManyEntries(hashes))
+  async getMany(
+    hashes: readonly string[],
+    ctx?: (hash: string) => CacheGetContext,
+  ): Promise<Map<string, CacheEntry>> {
+    return this.guard(async () => {
+      const out = await this.getManyEntries(hashes)
+      if (ctx === undefined || !this.write || out.size === hashes.length) return out
+      // An artifact the index does not know is still a hit (`adopt`).
+      for (const hash of hashes) {
+        if (out.has(hash) || !(await this.adopt(hash, ctx(hash)))) continue
+        const entry = await this.readEntry(hash)
+        if (entry !== null) out.set(hash, entry)
+      }
+      return out
+    })
   }
 
   private async getManyEntries(hashes: readonly string[]): Promise<Map<string, CacheEntry>> {

package/src/cache/layer.ts

@@ -565,9 +565,12 @@ export interface CacheLayer {
   /**
    * Optional batched `get` (same answers, fewer round trips). The
    * short-circuit probe uses it when a layer offers one; a layer without it
-   * is probed hash by hash.
+   * is probed hash by hash. `ctx` is each hash's `get` context.
    */
-  getMany?(hashes: readonly string[]): Promise<Map<string, CacheEntry>>
+  getMany?(
+    hashes: readonly string[],
+    ctx?: (hash: string) => CacheGetContext,
+  ): Promise<Map<string, CacheEntry>>
   /**
    * Lightweight existence probe. `'local'` / `'remote'` names the layer
    * that holds the artifact; `null` is a miss. NEVER moves bytes: no

package/src/cli/cache.ts

@@ -176,7 +176,7 @@ async function pruneCmd(args: readonly string[]): Promise<number> {
     const earlier = await Cache.orphansBeforeReset(dir)
     if (earlier !== null) {
       warnToStderr(
-        `[vx] the cache index is schema ${earlier.found} from an earlier vx: the prune resets it first, and every artifact past the hour's grace is then an orphan`,
+        `[vx] the cache index is schema ${earlier.found} from another vx version: the prune resets it first, and every artifact past the hour's grace is then an orphan`,
       )
       printPruned({ evicted: 0, bytesFreed: 0, ...earlier }, true, json)
       return 0

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/doctor.ts

@@ -245,9 +245,9 @@ async function collectWorkspaceInfo(
     schemaVersion: SCHEMA_VERSION,
     cacheEntries: stats.entryCount,
     cacheBytes: stats.totalBytes,
-    // The index is authoritative, so a row-less artifact is bytes nothing
-    // will ever hit — and only `vx cache prune` reclaims them (after an
-    // upgrade's schema reset, most often).
+    // A row-less artifact is indexed again only when its task asks for its
+    // key; the rest only `vx cache prune` reclaims (after an upgrade's
+    // schema reset, most often).
     orphans: { artifacts: orphans.orphans, bytes: orphans.orphanBytes },
     runs24h: stats.runCountLast24h,
     hits24h: stats.hitCountLast24h,

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/local-shortcircuit.ts

@@ -46,6 +46,7 @@ import type { CacheEntry, CacheLayer, GitFilesCache } from '../cache/index.js'
 import type { TaskNode } from '../graph/index.js'
 import { deriveStableKeys, workspaceInputsReach } from './stable-keys.js'
 import type { HashCache } from './task-hash.js'
+import { getContext } from './remote-prefetch.js'
 
 export interface ShortCircuitArgs {
   nodes: Map<string, TaskNode>
@@ -138,7 +139,14 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
   if (args.cache.getMany !== undefined) {
     try {
       const endProbe = span('probe')
-      const hits = await args.cache.getMany(candidates.map((c) => c.hash))
+      const byHash = new Map(candidates.map((c) => [c.hash, c.node]))
+      const hits = await args.cache.getMany(
+        candidates.map((c) => c.hash),
+        (hash) => {
+          const node = byHash.get(hash)!
+          return getContext(node, node.config.exec?.command ?? '')
+        },
+      )
       endProbe()
       for (const { hash, node } of candidates) {
         const hit = hits.get(hash) ?? null
@@ -157,8 +165,7 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
     while (next < candidates.length) {
       const { hash, node } = candidates[next++]!
       try {
-        const command = node.config.exec?.command ?? ''
-        const hit = await args.cache.get(hash, { taskId: node.id, command })
+        const hit = await args.cache.get(hash, getContext(node, node.config.exec?.command ?? ''))
         preProbed.set(node.id, { hash, hit })
         if (hit !== null && !keptOut.has(node.id)) restoreTier.add(node.id)
       } catch {

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)
 }