@vzn/vx 0.0.646 → 0.0.649

package/src/report/path-links.ts

@@ -6,12 +6,19 @@
 
 import { statSync } from 'node:fs'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 
 // `src/a.ts`, `./a.ts:12`, `/abs/a.ts:12:5`, tsc's `src/a.ts(12,5)`. Not
 // after a word, dot, slash or `@`, so a URL's path or a scoped name's tail
-// never starts a match. Groups: file, then line and column of either form.
-const PATH =
-  /(?<![\w./@+-])((?:\/|\.{1,2}\/)?(?:[\w@.+-]+\/)*[\w@+-][\w@.+-]*\.[A-Za-z][A-Za-z0-9]{0,9})(?::(\d+)(?::(\d+))?|\((\d+),(\d+)\))?/g
+// never starts a match. Colour codes (`\x1b[4m`) are invisible: a path one
+// starts is linked (tasks run with FORCE_COLOR), one it splits from its
+// directory is not. Groups: file, then line and column of either form.
+const SGR = String.raw`\x1b\[[\d;]*m`
+const PATH = new RegExp(
+  String.raw`(?<!\x1b\[[\d;]*)(?:(?<![\w./@+-])|(?<=${SGR}))(?<![\w./@+-](?<!${SGR})(?:${SGR})+)` +
+    String.raw`((?:\/|\.{1,2}\/)?(?:[\w@.+-]+\/)*[\w@+-][\w@.+-]*\.[A-Za-z][A-Za-z0-9]{0,9})(?::(\d+)(?::(\d+))?|\((\d+),(\d+)\))?`,
+  'g',
+)
 
 /** A file a task's output names; `file` absolute. */
 export interface OutputLocation {
@@ -29,7 +36,8 @@ export function linkPaths(text: string, dir: string, isFile: (abs: string) => bo
   return text.replace(PATH, (match: string, file: string) => {
     const abs = path.resolve(dir, file)
     if (!isFile(abs)) return match
-    return `\x1b]8;;file://${encodeURI(abs)}\x1b\\${match}\x1b]8;;\x1b\\`
+    // Not `encodeURI`: it keeps a `#` or `?`, which the URL reads as its fragment or query.
+    return `\x1b]8;;${pathToFileURL(abs).href}\x1b\\${match}\x1b]8;;\x1b\\`
   })
 }
 

package/src/report/plain-output.ts

@@ -1,11 +1,12 @@
 import type { TaskNode } from '../graph/index.js'
 import type { Logger } from './logger.js'
 
-// A prefix that may yet complete as a CSI or OSC sequence. An escape cut
-// at a chunk's end is held for the next chunk: stripped alone, its
-// remainder (`1m`) reached the log as text.
+// A prefix that may yet complete as a CSI, OSC or charset sequence
+// (`tput sgr0` writes `\x1b(B`). An escape cut at a chunk's end is held for
+// the next chunk: stripped alone, its remainder (`1m`, `B`) reached the log
+// as text.
 // eslint-disable-next-line no-control-regex -- ESC is the point
-const PARTIAL_ESCAPE = /^\x1b(?:\[[0-?]*[ -/]*|\][^\x07\x1b]*\x1b?)?$/
+const PARTIAL_ESCAPE = /^\x1b(?:\[[0-?]*[ -/]*|\][^\x07\x1b]*\x1b?|[ -/]+)?$/
 
 /**
  * `sink` with terminal escapes stripped from task output. Tasks run with
@@ -34,12 +35,19 @@ export function plainOutput(sink: Logger): Logger {
     if (text !== '') write(node, text)
   }
   // Delegated one by one, never spread: an embedder's logger may be a class
-  // whose methods live on its prototype and read `this`.
+  // whose methods live on its prototype and read `this`. Every hook the sink
+  // has: a dropped `warn` put warnings on stdout, a dropped `runDone` left
+  // the live region under the footer.
   return {
     status: (line) => sink.status(line),
+    ...(sink.warn && { warn: (line) => sink.warn!(line) }),
     ...(sink.runStart && { runStart: (info) => sink.runStart!(info) }),
     ...(sink.taskStart && { taskStart: (node) => sink.taskStart!(node) }),
     ...(sink.runEnd && { runEnd: () => sink.runEnd!() }),
+    ...(sink.stepStart && { stepStart: (id) => sink.stepStart!(id) }),
+    ...(sink.stepEnd && { stepEnd: (id, info) => sink.stepEnd!(id, info) }),
+    ...(sink.runStop && { runStop: () => sink.runStop!() }),
+    ...(sink.runDone && { runDone: () => sink.runDone!() }),
     taskStdout(node, chunk) {
       const text = strip(`${node.id}\0out`, chunk)
       if (text !== '' || chunk === '') sink.taskStdout(node, text)

package/src/report/status-line.ts

@@ -5,14 +5,13 @@
 // ordinary write erases the status display first, writes its content,
 // then redraws, so the display can never interleave with task output.
 
-import { dumbTerminal, paint, ui, type ColorSupport } from '../util/index.js'
+import { dumbTerminal, paint, type ColorSupport } from '../util/index.js'
 import {
   formatListHeader,
   formatTaskRow,
   paintIdParts,
   pathNote,
   placeNote,
-  TIME_COL,
 } from './framed-output.js'
 import type { BlockedTask } from './forecast.js'
 
@@ -39,6 +38,9 @@ export interface StatusStream {
   rows?: number
 }
 
+/** A region's lines, or what builds them when it is drawn. */
+export type Region = readonly string[] | (() => readonly string[])
+
 export interface OutputWriter {
   /** True only when the stream is a TTY and the run isn't CI. */
   readonly enabled: boolean
@@ -56,9 +58,11 @@ export interface OutputWriter {
   setStatus(line: string, opts?: { force?: boolean }): void
   /**
    * Replace the multi-line status region. Same throttle contract as
-   * `setStatus`; the two share one display slot.
+   * `setStatus`; the two share one display slot. A function is called
+   * when the region is next drawn, once: a set the throttle coalesces
+   * builds nothing.
    */
-  setRegion(lines: readonly string[], opts?: { force?: boolean }): void
+  setRegion(lines: Region, opts?: { force?: boolean }): void
   /** Hand over what `coalesce` holds and write straight through from now on. */
   settle(): void
   /** Permanently remove the status display; later set* is a no-op. */
@@ -114,7 +118,7 @@ export function createOutputWriter(
     stream.write(text)
   }
 
-  let current: readonly string[] | null = null
+  let current: Region | null = null
   let shown = false
   // PHYSICAL rows the shown region occupies, not logical lines — see
   // `regionRows`.
@@ -200,13 +204,18 @@ export function createOutputWriter(
     // only repeat these bytes.
     cancelTrailing()
     const erase = shown ? eraseSeq() : CLEAR
+    // Built here, not at the set: a warm run's task events set the
+    // region hundreds of times inside one floor, and each build was a
+    // forecast pass and a summary render no frame showed (200 hits on a
+    // terminal: run graph 62 → 9 ms). Kept built: a write redraws it.
+    if (typeof current === 'function') current = current()
     const lines = fitted(current!)
     stream.write(erase + lines.join('\n'))
     shown = true
     shownRows = regionRows(lines)
     lastDraw = now()
   }
-  const set = (lines: readonly string[], o: { force?: boolean }): void => {
+  const set = (lines: Region, o: { force?: boolean }): void => {
     if (!enabled || dead) return
     current = lines
     if (!atLineStart || holds > 0) return
@@ -313,8 +322,6 @@ export function createOutputWriter(
   }
 }
 
-const IDLE = '#6b7280'
-
 export interface WorkerSlot {
   id: string
   startedMs: number
@@ -323,8 +330,6 @@ export interface WorkerSlot {
 }
 
 export interface StatusRegionState {
-  /** The terminal's height: a region taller folds its rows, never its summary. */
-  rows?: number
   /** The running task at the head of the longest unfinished chain. */
   critical?: string
   /** Where a running task runs, when not here (`TaskExecutor.running`); its row shows it. */
@@ -338,15 +343,23 @@ export interface StatusRegionState {
    * the honest end of their life.
    */
   pinnedPersistent: readonly string[]
-  /** Fixed-size slot array; null = idle worker. Index = display row. */
+  /** The running tasks by slot, null for a free one; a task past the slots follows them. */
   slots: readonly (WorkerSlot | null)[]
-  /** The blocked task an idle slot's row holds instead of `idle`, by the same index. */
-  blocked?: readonly (BlockedTask | null)[]
+  /** The list's height: one row per worker, whatever runs, so it never jumps. */
+  size?: number
+  /**
+   * The tasks the scheduler has picked for the next free workers, each
+   * nested under the running task it waits on, in the rows no running task
+   * takes; nothing further ahead.
+   */
+  next?: readonly BlockedTask[]
+  /** Each running task's count of the tasks it holds back: its `blocked` cell. */
+  blockedBy?: ReadonlyMap<string, number>
   /** The run was stopped: running rows say `aborting`, idle rows leave. */
   stopping?: boolean
   /**
    * vx's own steps still running, shown below the worker rows: no worker
-   * slot or `--concurrency` bounds them (M, 2026-10-15).
+   * slot or `--concurrency` bounds them (2026-10-15).
    */
   steps?: readonly WorkerSlot[]
   /** Clock value used for per-slot elapsed (injectable for tests). */
@@ -401,7 +414,7 @@ const INTERNAL = 'internal'
 /**
  * The list row of one of vx's own steps (`vx:uploads`), on the task grid
  * with `internal` in the cache column: a step is no task and caches
- * nothing (M, 2026-10-16: `4.60s success internal vx:keep-run`).
+ * nothing (2026-10-16: `4.60s success internal vx:keep-run`).
  */
 export function formatStepLine(
   id: string,
@@ -450,31 +463,39 @@ export function formatStatusRegion(
         '',
         paintPinnedId(id, colors),
         colors,
+        // A blank `blocked` cell, so the id sits under the header's `task`.
+        '',
       ),
     )
   }
 
-  // Worker rows: NO glyph — the live elapsed time leads (no spinner;
-  // the ticking time IS the motion), then `running`, full id (never
-  // truncated — name is the last column). Idle rows hold their slot's
-  // place, dim, aligned under the status column: the blocked task the row
-  // holds and what holds it back, else `idle`.
-  // One task running has no path to compare against.
-  const busy = s.slots.filter((x) => x !== null && x.waiting !== true).length
-  for (const [row, slot] of s.slots.entries()) {
-    // Placed by an executor (DTE), the list is what runs: blocked tasks are
-    // the tasks line's count alone (M, 2026-10-21).
-    if (slot === null && (s.stopping === true || s.where !== undefined)) continue
-    if (slot === null) {
-      const w = s.blocked?.[row]
-      lines.push(
-        w == null
-          ? `${' '.repeat(3 + TIME_COL + 1)}${paint(IDLE, 'idle', colors, { dim: true })}`
-          : formatTaskRow(' ', null, 'blocked', '', '', '', paintPinnedId(w.id, colors), colors) +
-              `  ${dim(`by ${w.by}`)}`,
-      )
-      continue
+  // Running rows: NO glyph — the live elapsed time leads (no spinner;
+  // the ticking time IS the motion), then `running`, the usual duration,
+  // how many tasks wait on it, and the full id (never truncated — name is
+  // the last column). The rows no task runs in hold the tasks planned
+  // next, each nested under what it waits on; the rest stay blank, so the
+  // list keeps its height.
+  const running = s.slots.filter((x): x is WorkerSlot => x !== null && x.waiting !== true)
+  // Placed by an executor (DTE), the list is what runs: blocked tasks are
+  // the tasks line's count alone, and its size is no machine's.
+  const placed = s.where !== undefined
+  const free = Math.max(0, (s.size ?? 0) - running.length)
+  const nested = new Map<string, BlockedTask[]>()
+  if (!placed && s.stopping !== true) {
+    const ids = new Set(running.map((x) => x.id))
+    let n = 0
+    for (const b of s.next ?? []) {
+      if (n === free) break
+      if (!ids.has(b.by)) continue
+      let list = nested.get(b.by)
+      if (list === undefined) nested.set(b.by, (list = []))
+      list.push(b)
+      n++
     }
+  }
+  let rows = 0
+  for (const slot of running) {
+    rows++
     if (s.stopping === true) {
       lines.push(
         formatTaskRow(
@@ -486,15 +507,12 @@ export function formatStatusRegion(
           '',
           paintPinnedId(slot.id, colors),
           colors,
+          '',
         ),
       )
       continue
     }
-    // Handed to an executor that has no machine on it yet: no row, only
-    // the tasks line's `scheduled` (M, 2026-10-21).
-    if (slot.waiting === true) continue
     const at = s.where?.(slot.id)
-    const critical = s.critical === slot.id && busy > 1
     const usual = s.expected?.get(slot.id)
     lines.push(
       formatTaskRow(
@@ -506,11 +524,29 @@ export function formatStatusRegion(
         '',
         paintPinnedId(slot.id, colors),
         colors,
+        String(s.blockedBy?.get(slot.id) ?? 0),
       ) +
-        (critical ? pathNote(colors) : '') +
+        (s.critical === slot.id ? pathNote(colors) : '') +
         (at != null ? placeNote(at, colors) : ''),
     )
+    for (const b of nested.get(slot.id) ?? []) {
+      rows++
+      lines.push(
+        formatTaskRow(
+          ' ',
+          null,
+          'blocked',
+          '',
+          '',
+          '',
+          `${dim('\u2514')} ${paintPinnedId(b.id, colors)}`,
+          colors,
+          '',
+        ),
+      )
+    }
   }
+  if (!placed) for (; rows < (s.size ?? 0); rows++) lines.push('')
   for (const step of s.steps ?? []) {
     lines.push(
       formatTaskRow(
@@ -522,20 +558,11 @@ export function formatStatusRegion(
         '',
         paintPinnedId(step.id, colors),
         colors,
+        '',
       ),
     )
   }
-  if (lines.length > 1) lines.splice(1, 0, formatListHeader(s.where !== undefined, colors))
-  // A region taller than the terminal (a row spared) folds the rows past
-  // what fits into one line: the writer would cut the summary at its
-  // foot, and lines never printed cannot be scrolled to (M, 2026-10-21).
-  const room = s.rows === undefined ? Infinity : s.rows - 1 - s.summaryLines.length
-  if (lines.length > room && room >= 3) {
-    const kept = room - 1
-    const more = lines.length - kept
-    lines.length = kept
-    lines.push(`${' '.repeat(3 + TIME_COL + 1)}${dim(`+${more} more`)}`)
-  }
+  if (lines.length > 1) lines.splice(1, 0, formatListHeader(placed, colors, true))
   // The live summary section — identical shape to the final printout,
   // so the region visually BECOMES the summary when the run ends.
   lines.push(...s.summaryLines)
@@ -544,11 +571,12 @@ export function formatStatusRegion(
 
 /**
  * A running task's usual duration, fixed while the elapsed time counts up
- * toward it (M, 2026-10-14): `~5.2s`, `~42s`, `~2m 05s`. Fits the cache
+ * toward it (2026-10-14): `~5.2s`, `~42s`, `~2m 05s`. Fits the cache
  * column below 100 minutes.
  */
 function formatExpected(ms: number): string {
-  if (ms < 1000) return `~${Math.round(ms)}ms`
+  // The tier by the rounded value: 999.6 ms printed `~1000ms` (item 1034's class).
+  if (Math.round(ms) < 1000) return `~${Math.round(ms)}ms`
   if (ms < 9950) return `~${(ms / 1000).toFixed(1)}s`
   const s = Math.round(ms / 1000)
   if (s < 60) return `~${s}s`

package/src/report/summary.ts

@@ -13,6 +13,7 @@ import {
   formatBytes,
   formatElapsed,
   gradientRule,
+  identityColor,
   paint,
   SUCCESS,
   ui,
@@ -113,10 +114,12 @@ export interface SummaryStats {
   held?: { count: number; sumMs: number }
   /** Live section only: the forecast of what is left, from history. */
   etaMs?: number
+  /** Live section only: how long the run has gone past that forecast. */
+  overMs?: number
   /** A run of groups only: their names, so `0 tasks` says why. */
   emptyGroups?: readonly string[]
-  /** Each finished task's cache bucket by its key and its id (its run bytes), so its remote traffic can move it. */
-  buckets?: ReadonlyMap<string, CacheBucket>
+  /** Each finished task's id and cache bucket by its key and its id (its run bytes), so its remote traffic can move it. */
+  buckets?: ReadonlyMap<string, TaskBucket>
 }
 
 /** The cache bar segment a finished task fills before its remote traffic is weighed. */
@@ -129,6 +132,12 @@ export type CacheBucket =
   | 'saved'
   | 'notSaved'
 
+/** A finished task's id and cache bucket, as `SummaryStats.buckets` holds them. */
+export interface TaskBucket {
+  task: string
+  bucket: CacheBucket
+}
+
 /** A finished task's own cache bucket; none for a group, a skip or an abort. */
 export function cacheBucketOf(o: TaskOutcome): CacheBucket | undefined {
   if (isGroupTask(o.node)) return undefined
@@ -152,10 +161,12 @@ export function cacheBucketOf(o: TaskOutcome): CacheBucket | undefined {
   }
 }
 
-type Buckets = Record<CacheBucket | 'uploaded' | 'uploading' | 'remoteFailed', number>
+type RemoteState = 'uploaded' | 'uploading' | 'remoteFailed'
+const REMOTE_RANK: Record<RemoteState, number> = { uploaded: 0, uploading: 1, remoteFailed: 2 }
+type Buckets = Record<CacheBucket | RemoteState, number>
 
 /**
- * The cache bar's segments, each task in one (M, 2026-10-15). With layers
+ * The cache bar's segments, each task in one (2026-10-15). With layers
  * named, a saved task leaves the misses, and a task with remote traffic
  * leaves its own bucket for its strongest remote state: a failed read or
  * write, then an upload still running, then one that landed. Without, the
@@ -164,7 +175,7 @@ type Buckets = Record<CacheBucket | 'uploaded' | 'uploading' | 'remoteFailed', n
 function cacheBuckets(stats: SummaryStats, layers: RunContext['cache']): Buckets {
   const saved = layers === undefined ? 0 : (stats.saved ?? 0)
   // Its own yellow segment, as its legend count is: in the misses' red it
-  // was a cell with no count under it (M, 2026-10-21).
+  // was a cell with no count under it (2026-10-21).
   const notSaved = layers === undefined ? 0 : (stats.notSaved ?? 0)
   const b: Buckets = {
     miss: stats.miss - saved - notSaved,
@@ -179,13 +190,20 @@ function cacheBuckets(stats: SummaryStats, layers: RunContext['cache']): Buckets
     remoteFailed: 0,
   }
   if (layers?.remote !== true || stats.buckets === undefined) return b
-  for (const [hash, k] of layers.traffic.keys) {
-    const from = stats.buckets.get(hash)
+  // A task's traffic may sit under its key (its entry) and its id (its run
+  // bytes): it moves once, to the strongest state of the two.
+  const moved = new Map<string, RemoteState>()
+  for (const [key, k] of layers.traffic.keys) {
+    const from = stats.buckets.get(key)
     // Still running: it counts once it ends.
     if (from === undefined) continue
-    b[from]--
-    b[k.failures.length > 0 ? 'remoteFailed' : k.uploading > 0 ? 'uploading' : 'uploaded']++
+    const state: RemoteState =
+      k.failures.length > 0 ? 'remoteFailed' : k.uploading > 0 ? 'uploading' : 'uploaded'
+    const prior = moved.get(from.task)
+    if (prior === undefined) b[from.bucket]--
+    if (prior === undefined || REMOTE_RANK[state] > REMOTE_RANK[prior]) moved.set(from.task, state)
   }
+  for (const state of moved.values()) b[state]++
   return b
 }
 
@@ -234,6 +252,8 @@ export interface RunContext {
   }
   /** Total projects discovery found — the bar's denominator. */
   workspaceProjectCount?: number
+  /** The run's warnings no task owns, as they were said: the footer's `warn` row. */
+  warnings?: () => readonly string[]
 }
 
 export function formatSummarySection(
@@ -264,7 +284,7 @@ export function formatSummarySection(
 
   // Tasks meter + numbers, fixed order: failed · success · skipped ·
   // aborted · not run, then a dim total, last on its line. Every task in
-  // the run counts, each state its own segment (M, 2026-10-14).
+  // the run counts, each state its own segment (2026-10-14).
   const runTotal = stats.total + aborted + notRun
   const taskParts: string[] = []
   if (stats.failed > 0)
@@ -276,6 +296,8 @@ export function formatSummarySection(
   if (running > 0) taskParts.push(paint(RUNNING, `${running} running`, colors))
   if (scheduled > 0) taskParts.push(dim(`${scheduled} scheduled`))
   if (blocked > 0) taskParts.push(dim(`${blocked} blocked`))
+  // What is not done yet, running included: the count the bar's unfilled part shows.
+  if (left > 0) taskParts.push(dim(`${left} left`))
   if (runTotal > 0) taskParts.push(dim(`${runTotal} total`))
   const taskBar = segmentBar(
     [
@@ -307,10 +329,10 @@ export function formatSummarySection(
     const wsTotal = context.workspaceProjectCount
     if (wsTotal !== undefined && wsTotal > 0) {
       const width = barWidth(colors)
-      const cells = Math.min(
-        width,
-        Math.max(1, Math.round((context.packageCount / wsTotal) * width)),
-      )
+      const cells =
+        context.packageCount === 0
+          ? 0
+          : Math.min(width, Math.max(1, Math.round((context.packageCount / wsTotal) * width)))
       const bar =
         paint(WARN, '▰'.repeat(cells), colors) +
         paint('', '▱'.repeat(width - cells), colors, { dim: true })
@@ -362,7 +384,7 @@ export function formatSummarySection(
     )
     const cacheParts: string[] = []
     if (layers !== undefined) {
-      // Per layer (M, 2026-10-15): `✓` fresh (outputs already on disk, from
+      // Per layer (2026-10-15): `✓` fresh (outputs already on disk, from
       // either layer) and `∅` no cache, both local; `↓` restored from a
       // layer, `↑` saved to it; `✗` a remote read or write failed, `⇡` still
       // uploading. Each count is its bar segment's, glyph and number in its colour.
@@ -374,7 +396,7 @@ export function formatSummarySection(
         ...(layers.local ? n(b.restoredLocal, '\u2193', LOCAL) : []),
         ...(layers.localWrite ? n(b.saved, '\u2191', LOCAL) : []),
       ]
-      // The layer words are dim; only the counts carry colour (M, 2026-10-15).
+      // The layer words are dim; only the counts carry colour (2026-10-15).
       if (local.length > 0) cacheParts.push(`${dim('local')} ${local.join(' ')}`)
       // Each transfer count is followed by its bytes, dim: what the
       // remote moved is the cost a hit or an upload paid.
@@ -408,7 +430,7 @@ export function formatSummarySection(
     }
     // Skipped tasks ride the bar, yellow like the tasks meter, so the two
     // bars fill alike; their count is the tasks legend's alone (the footer
-    // never says a fact twice, M, 2026-10-14).
+    // never says a fact twice, 2026-10-14).
     lines.push(row('cache', cacheBar))
     if (cacheParts.length > 0) lines.push(legend(cacheParts))
   }
@@ -416,7 +438,7 @@ export function formatSummarySection(
   // Cache-miss duration spread (owner: hits' restore times polluted
   // it — only tasks that actually executed count). Dim: context.
   // A value already on the row is not said again: one executed task read
-  // as its own max, avg and min (M, 2026-10-14). Tasks that all took the
+  // as its own max, avg and min (2026-10-14). Tasks that all took the
   // same time have no spread to show.
   const total = formatElapsed(totalMs)
   const said = new Set([total])
@@ -442,6 +464,8 @@ export function formatSummarySection(
   // that is about the future.
   if (stats.etaMs !== undefined)
     timeParts.push(paint(ACCENT, `${formatEta(stats.etaMs)} left`, colors))
+  else if (stats.overMs !== undefined)
+    timeParts.push(paint(ACCENT, `${formatOver(stats.overMs)} over`, colors))
   for (const p of spreadParts) timeParts.push(dim(p))
   const timeRow = row('time', join(timeParts))
   // Run-shape footer (final summary only): worker pool + cache mode,
@@ -480,13 +504,33 @@ export function formatSummarySection(
       )
     }
     if (context.runId !== undefined) info.push(`run ${context.runId}`)
-    lines.push('', row('info', join(info)), timeRow)
+    lines.push('', ...warnRows(context.warnings?.() ?? [], row, colors))
+    lines.push(row('info', join(info)), timeRow)
   } else {
     lines.push('', timeRow)
   }
   return lines
 }
 
+/**
+ * A long run scrolls its warnings (a remote cache's 403, a plugin's
+ * failed flush) out of sight, and the footer read as a clean run
+ * (2026-10-27). The footer counts the distinct ones; it does not repeat
+ * them, so a warning stays one line in a log (a refused token costs
+ * ONE line, tests/remote-cache-degrade.test.ts in @vzn/vx-migrate).
+ */
+function warnRows(
+  warnings: readonly string[],
+  row: (label: string, value: string) => string,
+  colors: ColorSupport,
+): string[] {
+  const n = new Set(
+    warnings.map((w) => Bun.stripANSI(w).split('\n')[0]!.trim()).filter((w) => w !== ''),
+  ).size
+  if (n === 0) return []
+  return [row('warn', paint(WARN, `${n} ${n === 1 ? 'warning' : 'warnings'} above`, colors))]
+}
+
 /**
  * A forecast, said as coarsely as it is known: `~4s`, `~2m 05s`, `<1s`
  * once the history says the end is due.
@@ -498,16 +542,27 @@ function formatEta(ms: number): string {
   return `~${Math.floor(s / 60)}m ${String(s % 60).padStart(2, '0')}s`
 }
 
+function formatOver(ms: number): string {
+  const s = Math.max(1, Math.ceil(ms / 1000))
+  return s < 60 ? `+${s}s` : `+${Math.floor(s / 60)}m ${String(s % 60).padStart(2, '0')}s`
+}
+
 /**
  * The `--verbosity 1` per-task table (`RunOptions.summaryTable`). Groups are
- * left out as the footer and `--report` leave them: a group ran no command.
+ * left out as the footer leaves them: a group ran no command. Painted in the
+ * list's vocabulary: header bold violet, ids in their hues, status in its
+ * state colour, rule and durations dim.
  */
-export function formatOutcomeTable(outcomes: readonly TaskOutcome[]): string[] {
+export function formatOutcomeTable(
+  outcomes: readonly TaskOutcome[],
+  colors: ColorSupport = NO_COLOR,
+): string[] {
   const rows = outcomes
     .filter((o) => !isGroupTask(o.node))
     .map((o) => {
       const v = projectOutcome(o)
-      return { task: v.taskId, status: outcomeLabel(v), duration: `${v.durationMs}ms` }
+      const status = neverStarted(o) ? 'not run' : outcomeLabel(v)
+      return { o, task: v.taskId, status, duration: `${v.durationMs}ms` }
     })
   if (rows.length === 0) return []
   const widths = {
@@ -515,17 +570,43 @@ export function formatOutcomeTable(outcomes: readonly TaskOutcome[]): string[] {
     status: Math.max(6, ...rows.map((r) => r.status.length)),
     duration: Math.max(8, ...rows.map((r) => r.duration.length)),
   }
-  const line = (task: string, status: string, duration: string) =>
-    `${task.padEnd(widths.task)}  ${status.padEnd(widths.status)}  ${duration.padStart(widths.duration)}`
-  const header = line('TASK', 'STATUS', 'DURATION')
+  const pad = (text: string, width: number) => ' '.repeat(Math.max(0, width - text.length))
+  const header = `${'TASK'.padEnd(widths.task)}  ${'STATUS'.padEnd(widths.status)}  ${'DURATION'.padStart(widths.duration)}`
+  const dim = (t: string) => paint('', t, colors, { dim: true })
   return [
     '',
-    header,
-    '-'.repeat(header.length),
-    ...rows.map((r) => line(r.task, r.status, r.duration)),
+    paint(TABLE_HEADER, header, colors, { bold: true }),
+    dim('-'.repeat(header.length)),
+    ...rows.map((r) => {
+      const { node } = r.o
+      const id =
+        node.projectName !== undefined && node.taskName !== undefined
+          ? paint(identityColor(node.projectName), node.projectName, colors) +
+            dim('#') +
+            paint(identityColor(node.taskName), node.taskName, colors)
+          : r.task
+      const status = paint(tableStatusColor(r.o), r.status, colors)
+      return `${id}${pad(r.task, widths.task)}  ${status}${pad(r.status, widths.status)}  ${pad(r.duration, widths.duration)}${dim(r.duration)}`
+    }),
   ]
 }
 
+/** violet-400, as the task list's header. */
+const TABLE_HEADER = '#a78bfa'
+
+function tableStatusColor(o: TaskOutcome): string {
+  switch (o.status) {
+    case 'failed':
+      return ERROR
+    case 'skipped':
+      return WARN
+    case 'aborted':
+      return neverStarted(o) ? NOT_RUN : ABORTED
+    default:
+      return SUCCESS
+  }
+}
+
 // Local byte formatter — the orchestrator can't import cli/format.ts
 // (module boundary), and the footer only needs one compact form.
 /** Ran here with a `cache` block, succeeded, and its result was not saved. */
@@ -598,13 +679,14 @@ export function formatRunSummary(
 }
 
 /** Each finished task's cache bucket by its key and by its id. */
-function bucketsOf(outcomes: readonly TaskOutcome[]): Map<string, CacheBucket> {
-  const out = new Map<string, CacheBucket>()
+function bucketsOf(outcomes: readonly TaskOutcome[]): Map<string, TaskBucket> {
+  const out = new Map<string, TaskBucket>()
   for (const o of outcomes) {
     const bucket = cacheBucketOf(o)
     if (bucket === undefined) continue
-    if (o.hash !== undefined) out.set(o.hash, bucket)
-    out.set(o.node.id, bucket)
+    const entry = { task: o.node.id, bucket }
+    if (o.hash !== undefined) out.set(o.hash, entry)
+    out.set(o.node.id, entry)
   }
   return out
 }