@vzn/vx 0.0.649 → 0.0.650

package/src/report/framed-output.ts

@@ -292,9 +292,14 @@ function paintTaskId(node: TaskNode, colors: ColorSupport, opts: { bold?: boolea
 export const TIME_COL = 7 // "0ms" … "999.99s", then "16m 40s" … "99m 59s"
 const STATUS_COL = 7 // "success" / "running" / "skipped" / "aborted" / "not run"
 const CACHE_COL = 8 // "no-cache" / "remote" / "local" / "fresh" / "miss"
-const BLOCKED_COL = 7 // the live list's count of tasks a running one holds back
+const BLOCKED_COL = 7 // `blocks`: how many tasks are downstream of the row's
+const USUAL_COL = 7 // "~18s" live, "+6.0s" / "−1m 05s" after
+const WAITED_COL = 7 // the time cell's width: "1.20s"
+const CPU_COL = 5 // "180%", "1200%"
+const MEM_COL = 6 // "412MB", "1.1GB", "1023MB"
+const OUT_COL = 7 // `outputs`: "12MB", "900B"
+const WORKER_COL = 12 // `local`, or a plugin's name for the machine, cut at 12
 /** The list header's colour: violet-400, the summary rule's first stop. */
-const HEADER = '#a78bfa'
 
 /** Right-align the duration in a TIME_COL cell (pad on the left). */
 function timeCell(ms: number | null, colors: ColorSupport): string {
@@ -375,10 +380,11 @@ function taskGlyph(o: TaskOutcome, colors: ColorSupport): string {
 }
 
 /**
- * One reported task row: `<glyph> <time> <status> <cache> <name>`.
- * `glyph` is pre-painted; status/cache are raw text + color, padded to
- * their columns; `paintedId` carries identity coloring. `ms = null`
- * blanks the time (e.g. a skip never ran); `cache = ''` blanks it.
+ * One reported task row on the list grid: `<glyph> <time> <usual> <waited>
+ * <status> <cache> <cpu> <mem> <blocks> <worker> <name>`. `glyph` is
+ * pre-painted; status/cache are raw text + color, padded to their
+ * columns; `paintedId` carries identity coloring. `ms = null` blanks the
+ * time (a skip never ran); `cache = ''` and an absent cell blank theirs.
  */
 export function formatTaskRow(
   glyph: string,
@@ -389,32 +395,118 @@ export function formatTaskRow(
   cacheColor: string,
   paintedId: string,
   colors: ColorSupport = NO_COLOR,
-  /** The live list's `blocked` cell, right-aligned before the id; absent off that list. */
-  blocked?: string,
+  cells: RowCells = {},
 ): string {
   const st = cell(status, statusColor, STATUS_COL, colors)
   // `aborting` runs one into the cache cell, which is blank beside it.
   const ca = cell(cache, cacheColor, CACHE_COL - Math.max(0, status.length - STATUS_COL), colors)
-  const bl =
-    blocked === undefined
-      ? ''
-      : `${' '.repeat(Math.max(0, BLOCKED_COL - blocked.length))}${paint(WARN, blocked, colors)} `
-  return ` ${glyph} ${timeCell(ms, colors)} ${st} ${ca} ${bl}${paintedId}`
+  const usual = cells.usual ?? { text: '', painted: '' }
+  const us = `${' '.repeat(Math.max(0, USUAL_COL - usual.text.length))}${usual.painted}`
+  const waited = cells.waitedMs === undefined ? '' : formatElapsed(cells.waitedMs)
+  const cpu = cells.cpu === undefined ? '' : `${Math.round(cells.cpu * 100)}%`
+  const mem = cells.memBytes === undefined ? '' : formatSize(cells.memBytes)
+  const out = cells.outputBytes === undefined ? '' : formatSize(cells.outputBytes)
+  const blocks = cells.blocks ?? ''
+  const worker = workerName(cells.worker ?? '')
+  return (
+    ` ${glyph} ${timeCell(ms, colors)} ${us} ${right(waited, WAITED_COL, colors)} ${st} ${ca} ` +
+    `${right(cpu, CPU_COL, colors)} ${right(mem, MEM_COL, colors)} ${right(out, OUT_COL, colors)} ` +
+    `${' '.repeat(Math.max(0, BLOCKED_COL - blocks.length))}${paint(WARN, blocks, colors)} ` +
+    `${worker === '' ? '' : ui.inline(ui.place(worker), colors)}${' '.repeat(WORKER_COL - worker.length)} ${paintedId}`
+  )
+}
+
+/** A row's cells past time, status and cache; each blank when absent. */
+export interface RowCells {
+  /** After the time, pre-painted: `~18s` live, `+6.0s` / `−1.4s` after. */
+  usual?: { text: string; painted: string }
+  /** How long the task waited ready for a slot. */
+  waitedMs?: number
+  /** Cores in use (live) or on average (after): 1.8 prints `180%`. */
+  cpu?: number
+  /** Resident memory now (live) or at its peak (after). */
+  memBytes?: number
+  /** The bytes of the task's outputs: what its save stored, or its hit restored. */
+  outputBytes?: number
+  /** How many tasks are downstream. */
+  blocks?: string
+  /** The machine it runs or ran on: `local`, or the executor's name for it. */
+  worker?: string
+}
+
+function right(text: string, width: number, colors: ColorSupport): string {
+  return ' '.repeat(Math.max(0, width - text.length)) + paint('', text, colors, { dim: true })
+}
+
+/** `900B`, `412MB`, `1.1GB`: one width for a size, whatever it is. */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  const mb = bytes / 1024 / 1024
+  if (mb < 1) return `${Math.round(bytes / 1024)}KB`
+  if (mb < 9.95) return `${mb.toFixed(1)}MB`
+  if (mb < 1000) return `${Math.round(mb)}MB`
+  const gb = mb / 1024
+  return gb < 10 ? `${gb.toFixed(1)}GB` : `${Math.round(gb)}GB`
+}
+
+/** A worker's name in its 12 columns: a longer one ends in `…`. */
+function workerName(name: string): string {
+  return name.length > WORKER_COL ? `${name.slice(0, WORKER_COL - 1)}\u2026` : name
 }
 
 /**
- * The header over a task list, on the row grid: bold and coloured, so it
- * reads apart from the rows (dim, it was lost among them). `worker` when an
- * executor places tasks: the name after the id's dot. `blocked` on the live
- * list, whose rows count the tasks each running one holds back.
+ * A wait worth a cell: under 50 ms the task started at once, the
+ * scheduler's own tick and a sibling's spawn, not a full pool.
  */
-export function formatListHeader(
-  worker: boolean,
+export function waited(ms: number | undefined): boolean {
+  return ms !== undefined && ms >= 50
+}
+
+/** A task's average cores over its run: CPU time over wall time. */
+function coresOf(o: TaskOutcome): number | undefined {
+  return o.cpuMs === undefined || o.durationMs <= 0 ? undefined : o.cpuMs / o.durationMs
+}
+
+/**
+ * The results list's `±usual` cell: how far an executed task ran from its
+ * usual time, `+6.0s` red or `−1.4s` green, only past a fifth of the usual
+ * either way; blank with no usual time to compare.
+ */
+function usualDelta(
+  ms: number,
+  usualMs: number | undefined,
   colors: ColorSupport = NO_COLOR,
-  blocked = false,
-): string {
-  const head = `   ${'time'.padStart(TIME_COL)} ${'status'.padEnd(STATUS_COL)} ${'cache'.padEnd(CACHE_COL)} ${blocked ? `${'blocked'.padStart(BLOCKED_COL)} ` : ''}task${worker ? ' \u00b7 worker' : ''}`
-  return paint(HEADER, head, colors, { bold: true })
+): { text: string; painted: string } {
+  if (usualMs === undefined || usualMs <= 0 || Math.abs(ms - usualMs) <= usualMs * 0.2)
+    return { text: '', painted: '' }
+  const d = ms - usualMs
+  const text = `${d > 0 ? '+' : '\u2212'}${formatElapsed(Math.abs(d), true)}`
+  return { text, painted: paint(d > 0 ? ERROR : SUCCESS, text, colors) }
+}
+
+/**
+ * The header over a task list, on the row grid: dim and underlined across
+ * the whole line, gaps included, straight over its rows (bold in a hue, it
+ * blended into rows of the same hues).
+ */
+export function formatListHeader(colors: ColorSupport = NO_COLOR): string {
+  return header('\u00b1usual', colors)
+}
+
+/**
+ * The live list's header: the usual duration where the results list has
+ * how far a task ran from it; the other columns are the results'.
+ */
+export function formatRunningHeader(colors: ColorSupport = NO_COLOR): string {
+  return header('usual', colors)
+}
+
+function header(usual: string, colors: ColorSupport): string {
+  const head =
+    `   ${'time'.padStart(TIME_COL)} ${usual.padStart(USUAL_COL)} ${'waited'.padStart(WAITED_COL)} ` +
+    `${'status'.padEnd(STATUS_COL)} ${'cache'.padEnd(CACHE_COL)} ${'cpu'.padStart(CPU_COL)} ` +
+    `${'mem'.padStart(MEM_COL)} ${'outputs'.padStart(OUT_COL)} ${'blocks'.padStart(BLOCKED_COL)} ${'worker'.padEnd(WORKER_COL)} task`
+  return paint('', head, colors, { dim: true, underline: true })
 }
 
 /** Compact one-liner for a cache hit with nothing to replay. */
@@ -423,8 +515,11 @@ export function formatTaskHitLine(
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
   onPath = false,
+  blocks?: number,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath, {
+    ...ranCells(o, blocks),
+  })
 }
 
 /**
@@ -448,8 +543,34 @@ export function formatTaskExecutedLine(
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
   onPath = false,
+  blocks?: number,
+  usualMs?: number,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath, {
+    ...executedCells(o, blocks),
+    usual: usualDelta(o.durationMs, usualMs, colors),
+  })
+}
+
+/** An executed task's cells: where and how long it waited, its average cores and peak memory. */
+export function executedCells(o: TaskOutcome, blocks: number | undefined): RowCells {
+  const cores = coresOf(o)
+  return {
+    ...ranCells(o, blocks),
+    ...(cores !== undefined ? { cpu: cores } : {}),
+    ...(o.peakRssBytes !== undefined ? { memBytes: o.peakRssBytes } : {}),
+  }
+}
+
+/** The cells every row of a task that reached a machine carries. */
+function ranCells(o: TaskOutcome, blocks: number | undefined): RowCells {
+  return {
+    // A skip reached no machine.
+    ...(o.status === 'skipped' ? {} : { worker: o.where ?? 'local' }),
+    ...(blocks !== undefined ? { blocks: String(blocks) } : {}),
+    ...(waited(o.queuedMs) ? { waitedMs: o.queuedMs! } : {}),
+    ...(o.outputBytes !== undefined ? { outputBytes: o.outputBytes } : {}),
+  }
 }
 
 /** Shared: render any outcome on the grid. */
@@ -459,6 +580,7 @@ function formatOutcomeRow(
   ms: number | null,
   colors: ColorSupport,
   onPath: boolean,
+  cells: RowCells,
 ): string {
   const st = statusOf(o)
   const ca = cacheOf(o)
@@ -472,9 +594,9 @@ function formatOutcomeRow(
       ca.color,
       paintedId,
       colors,
+      cells,
     ) +
     (onPath ? pathNote(colors) : '') +
-    whereNote(o, colors) +
     flakyNote(o, colors)
   )
 }
@@ -485,7 +607,7 @@ export function pathNote(colors: ColorSupport = NO_COLOR): string {
 }
 
 /** Where an executor ran the task, when not here, right after its id: `@small#2` (2026-10-21). */
-export function whereNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): string {
+function whereNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): string {
   return o.where === undefined ? '' : placeNote(o.where, colors)
 }
 
@@ -493,7 +615,7 @@ export function whereNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): stri
  * ` · <where>` after the id: the dot dim, the place in its own hue. Last
  * on the row, as a worker's name has no width to pad to (2026-10-21).
  */
-export function placeNote(where: string, colors: ColorSupport = NO_COLOR): string {
+function placeNote(where: string, colors: ColorSupport = NO_COLOR): string {
   return `${paint('', ' \u00b7', colors, { dim: true })} ${ui.inline(ui.place(where), colors)}`
 }
 
@@ -524,6 +646,7 @@ export function formatTaskSkippedLine(
   node: TaskNode,
   colors: ColorSupport = NO_COLOR,
   skip?: Parameters<typeof skippedReason>[0],
+  blocks?: number,
 ): string {
   const why = skippedReason(skip)
   const suffix = why === '' ? '' : ` ${paint('', `• ${why}`, colors, { dim: true })}`
@@ -537,6 +660,7 @@ export function formatTaskSkippedLine(
       '',
       paintTaskId(node, colors),
       colors,
+      blocks === undefined ? {} : { blocks: String(blocks) },
     ) + suffix
   )
 }
@@ -550,8 +674,10 @@ export function formatTaskAbortedLine(
   node: TaskNode,
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
+  blocks?: number,
 ): string {
   const id = paintTaskId(node, colors)
+  const bl: RowCells = blocks === undefined ? {} : { blocks: String(blocks) }
   if (neverStarted(o)) {
     return formatTaskRow(
       paint('', '\u25cc', colors, { dim: true }),
@@ -562,6 +688,7 @@ export function formatTaskAbortedLine(
       '',
       id,
       colors,
+      bl,
     )
   }
   return formatTaskRow(
@@ -573,6 +700,7 @@ export function formatTaskAbortedLine(
     '',
     id,
     colors,
+    ranCells(o, blocks),
   )
 }
 

package/src/report/index.ts

@@ -31,7 +31,8 @@ export {
   warnOf,
 } from './logger.js'
 export { formatPersistentList } from './framed-output.js'
-export { createForecast } from './forecast.js'
+export { blocksCounts, createForecast } from './forecast.js'
 export { fileLocations, fileMemo, type OutputLocation } from './path-links.js'
 export { plainOutput } from './plain-output.js'
+export type { LiveUsage } from './status-line.js'
 export { formatOutcomeTable, formatRunSummary } from './summary.js'

package/src/report/logger.ts

@@ -8,10 +8,11 @@ import {
   formatListHeader,
   formatTaskAbortedLine,
   formatTaskBlock,
+  executedCells,
+  waited,
   formatTaskExecutedLine,
   flakyNote,
   pathNote,
-  whereNote,
   formatTaskHashLine,
   formatTaskHitLine,
   formatTaskSkippedLine,
@@ -91,7 +92,8 @@ export interface Logger {
     /** The run's canonical start (epoch ms) — equals the final summary's `startedAt`. */
     startedAtMs?: number
   }): void
-  taskStart?(node: TaskNode): void
+  /** `waitedMs`: how long it waited ready for a slot, when not started at once. */
+  taskStart?(node: TaskNode, info?: { waitedMs?: number }): void
   /** The task graph finished (any outcome); vx's own closing steps follow. Idempotent. */
   runEnd?(): void
   /**
@@ -354,6 +356,8 @@ export function defaultLogger(
   const onPath = new Set<string>()
   let blockedCount = 0
   let expected: ReadonlyMap<string, number> | undefined
+  // Each task's usual time once history is read: the results' `±usual`.
+  let usualOf: ReadonlyMap<string, number> | undefined
   let blocked: readonly BlockedTask[] | undefined
   let blockedBy: ReadonlyMap<string, number> | undefined
   let etaAtMs = 0
@@ -521,6 +525,7 @@ export function defaultLogger(
       expected = f.expected
       blocked = f.blocked
       blockedBy = f.blockedBy
+      usualOf = f.usual
     }
     const etaMs = deadlineMs === undefined ? undefined : deadlineMs - now
     if (signals.progress && total > 0) {
@@ -604,6 +609,7 @@ export function defaultLogger(
         nowMs: Date.now(),
         summaryLines,
         ...(runContext?.whereRunning !== undefined ? { where: runContext.whereRunning } : {}),
+        ...(runContext?.usage !== undefined ? { usage: runContext.usage } : {}),
         ...(expected !== undefined ? { expected } : {}),
         ...(critical !== undefined ? { critical } : {}),
       },
@@ -688,7 +694,7 @@ export function defaultLogger(
   const emitRow = (line: string): void => {
     if (!headed) {
       headed = true
-      emitLine(formatListHeader(runContext?.whereRunning !== undefined, colors))
+      emitLine(formatListHeader(colors))
     }
     emitLine(line)
   }
@@ -731,10 +737,17 @@ export function defaultLogger(
     (framesTerminal && holdsTerminal(node)) ||
     (view.mode === 'focused' && isPrimary(node) && !isGroupTask(node) && requestedCount <= 1)
 
+  // How many tasks are downstream of each: every results row's `blocks`.
+  const blocksOf = (id: string): number | undefined => runContext?.blocks?.().get(id)
   const failureRow = (node: TaskNode, outcome: TaskOutcome): string =>
-    formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(outcome)) +
+    formatFailureLine(
+      node.id,
+      outcome.durationMs,
+      colors,
+      cacheWordOf(outcome),
+      executedCells(outcome, blocksOf(node.id)),
+    ) +
     (onPath.has(node.id) ? pathNote(colors) : '') +
-    whereNote(outcome, colors) +
     flakyNote(outcome, colors)
 
   return {
@@ -798,7 +811,7 @@ export function defaultLogger(
       tail = false
       killStatus()
     },
-    taskStart(node) {
+    taskStart(node, info) {
       if (isGroupTask(node)) return
       if (holdsTerminal(node)) {
         killStatus()
@@ -820,7 +833,12 @@ export function defaultLogger(
       }
       // The rows are the status region's; with none, nothing reads them.
       if (statusDead) return
-      const slot: WorkerSlot = { id: node.id, startedMs: Date.now() }
+      const slot: WorkerSlot = {
+        id: node.id,
+        startedMs: Date.now(),
+        cache: ranNoCache({ node }) ? 'no-cache' : 'miss',
+        ...(waited(info?.waitedMs) ? { waitedMs: info!.waitedMs! } : {}),
+      }
       const free = slots.indexOf(null)
       if (free >= 0) slots[free] = slot
       else slotQueue.push(slot)
@@ -1016,7 +1034,7 @@ export function defaultLogger(
         // 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') {
-          emitRow(formatTaskAbortedLine(node, outcome, colors))
+          emitRow(formatTaskAbortedLine(node, outcome, colors, blocksOf(node.id)))
         }
         return
       }
@@ -1099,7 +1117,7 @@ export function defaultLogger(
         }
         case 'errors-only':
           if (outcome.status === 'skipped') {
-            emitRow(formatTaskSkippedLine(node, colors, outcome))
+            emitRow(formatTaskSkippedLine(node, colors, outcome, blocksOf(node.id)))
             return
           }
           if (outcome.status !== 'failed') return
@@ -1136,9 +1154,18 @@ export function defaultLogger(
               ),
             )
           } else if (outcome.status === 'success') {
-            emitRow(formatTaskExecutedLine(node, outcome, colors, onPath.has(node.id)))
+            emitRow(
+              formatTaskExecutedLine(
+                node,
+                outcome,
+                colors,
+                onPath.has(node.id),
+                blocksOf(node.id),
+                usualOf?.get(node.id),
+              ),
+            )
           } else if (outcome.status === 'skipped') {
-            emitRow(formatTaskSkippedLine(node, colors, outcome))
+            emitRow(formatTaskSkippedLine(node, colors, outcome, blocksOf(node.id)))
           }
           return
         case 'focused':
@@ -1147,7 +1174,7 @@ export function defaultLogger(
             // stopped), so no frame-open fired — and a skip has no output,
             // so a one-liner carries everything a frame would.
             if (outcome.status === 'skipped') {
-              emitRow(formatTaskSkippedLine(node, colors, outcome))
+              emitRow(formatTaskSkippedLine(node, colors, outcome, blocksOf(node.id)))
               return
             }
             if (streamsLive(node)) {
@@ -1198,7 +1225,7 @@ export function defaultLogger(
           // 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') {
-            emitRow(formatTaskSkippedLine(node, colors, outcome))
+            emitRow(formatTaskSkippedLine(node, colors, outcome, blocksOf(node.id)))
           } else if (outcome.status === 'failed') {
             emitRow(failureRow(node, outcome))
             deferredFailures.push(
@@ -1222,11 +1249,13 @@ export function defaultLogger(
           // point); misses/failures are always framed. One-liners
           // stay outside ::group:: — there's nothing to collapse.
           if (isHit && output.every((c) => c.text.trim().length === 0)) {
-            emitRow(formatTaskHitLine(node, outcome, colors, onPath.has(node.id)))
+            emitRow(
+              formatTaskHitLine(node, outcome, colors, onPath.has(node.id), blocksOf(node.id)),
+            )
             return
           }
           if (outcome.status === 'skipped') {
-            emitRow(formatTaskSkippedLine(node, colors, outcome))
+            emitRow(formatTaskSkippedLine(node, colors, outcome, blocksOf(node.id)))
             return
           }
           const block = formatTaskBlock(

package/src/report/plain-output.ts

@@ -42,7 +42,7 @@ export function plainOutput(sink: Logger): Logger {
     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.taskStart && { taskStart: (node, info) => sink.taskStart!(node, info) }),
     ...(sink.runEnd && { runEnd: () => sink.runEnd!() }),
     ...(sink.stepStart && { stepStart: (id) => sink.stepStart!(id) }),
     ...(sink.stepEnd && { stepEnd: (id, info) => sink.stepEnd!(id, info) }),

package/src/report/status-line.ts

@@ -7,11 +7,11 @@
 
 import { dumbTerminal, paint, type ColorSupport } from '../util/index.js'
 import {
-  formatListHeader,
+  formatRunningHeader,
   formatTaskRow,
   paintIdParts,
   pathNote,
-  placeNote,
+  type RowCells,
 } from './framed-output.js'
 import type { BlockedTask } from './forecast.js'
 
@@ -327,6 +327,16 @@ export interface WorkerSlot {
   startedMs: number
   /** Its executor holds it for a machine to begin it (`TaskExecutor.running` is `null`). */
   waiting?: boolean
+  /** How long it waited ready for a slot; absent when it started at once. */
+  waitedMs?: number
+  /** Its cache cell: `no-cache` for a task that caches nothing, else `miss` (the default). */
+  cache?: 'miss' | 'no-cache'
+}
+
+/** What a running task's process tree uses now. */
+export interface LiveUsage {
+  cores: number
+  rssBytes: number
 }
 
 export interface StatusRegionState {
@@ -336,6 +346,8 @@ export interface StatusRegionState {
   where?: (taskId: string) => string | null | undefined
   /** A running task's usual duration from history; its row shows it. */
   expected?: ReadonlyMap<string, number>
+  /** A running task's live CPU and memory; its row's `cpu` and `mem`. */
+  usage?: (taskId: string) => LiveUsage | undefined
   /**
    * Ready persistent tasks (dev servers …) whose children keep
    * running after their outcome lands. Pinned until runEnd — the
@@ -395,6 +407,7 @@ export function formatFailureLine(
   durationMs: number | null,
   colors: ColorSupport = NO_COLOR,
   cacheWord: 'miss' | 'no-cache' = 'miss',
+  cells: RowCells = {},
 ): string {
   return formatTaskRow(
     paint(ERROR, '◼\uFE0E', colors),
@@ -405,6 +418,7 @@ export function formatFailureLine(
     '',
     paintPinnedId(id, colors),
     colors,
+    cells,
   )
 }
 
@@ -431,6 +445,7 @@ export function formatStepLine(
     '',
     paintPinnedId(id, colors),
     colors,
+    { worker: 'local' },
   )
 }
 
@@ -447,6 +462,12 @@ export function formatStatusRegion(
   colors: ColorSupport = NO_COLOR,
 ): string[] {
   const dim = (t: string) => paint('', t, colors, { dim: true })
+  // A task's usual duration, the live list's `usual` cell: `~18s`.
+  const usualOf = (id: string): { text: string; painted: string } => {
+    const ms = s.expected?.get(id)
+    const text = ms === undefined ? '' : formatExpected(ms)
+    return { text, painted: dim(text) }
+  }
   // Leading blank separates the live running region from the completed
   // task list scrolling above it (owner: "separate running from list").
   const lines: string[] = ['']
@@ -463,8 +484,7 @@ export function formatStatusRegion(
         '',
         paintPinnedId(id, colors),
         colors,
-        // A blank `blocked` cell, so the id sits under the header's `task`.
-        '',
+        { worker: 'local' },
       ),
     )
   }
@@ -507,27 +527,31 @@ export function formatStatusRegion(
           '',
           paintPinnedId(slot.id, colors),
           colors,
-          '',
+          { worker: s.where?.(slot.id) ?? 'local' },
         ),
       )
       continue
     }
     const at = s.where?.(slot.id)
-    const usual = s.expected?.get(slot.id)
+    const use = s.usage?.(slot.id)
     lines.push(
       formatTaskRow(
         ' ',
         Math.max(0, s.nowMs - slot.startedMs),
         'running',
         ACCENT,
-        usual === undefined ? '' : formatExpected(usual),
+        slot.cache ?? 'miss',
         '',
         paintPinnedId(slot.id, colors),
         colors,
-        String(s.blockedBy?.get(slot.id) ?? 0),
-      ) +
-        (s.critical === slot.id ? pathNote(colors) : '') +
-        (at != null ? placeNote(at, colors) : ''),
+        {
+          usual: usualOf(slot.id),
+          ...(slot.waitedMs !== undefined ? { waitedMs: slot.waitedMs } : {}),
+          ...(use !== undefined ? { cpu: use.cores, memBytes: use.rssBytes } : {}),
+          blocks: String(s.blockedBy?.get(slot.id) ?? 0),
+          worker: at ?? 'local',
+        },
+      ) + (s.critical === slot.id ? pathNote(colors) : ''),
     )
     for (const b of nested.get(slot.id) ?? []) {
       rows++
@@ -541,7 +565,7 @@ export function formatStatusRegion(
           '',
           `${dim('\u2514')} ${paintPinnedId(b.id, colors)}`,
           colors,
-          '',
+          { usual: usualOf(b.id) },
         ),
       )
     }
@@ -558,11 +582,11 @@ export function formatStatusRegion(
         '',
         paintPinnedId(step.id, colors),
         colors,
-        '',
+        { worker: 'local' },
       ),
     )
   }
-  if (lines.length > 1) lines.splice(1, 0, formatListHeader(placed, colors, true))
+  if (lines.length > 1) lines.splice(1, 0, formatRunningHeader(colors))
   // 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)

package/src/report/summary.ts

@@ -223,6 +223,10 @@ export interface RunContext {
   executorRows?: () => readonly (readonly [string, ui.Inline])[]
   /** Where a running task runs, `null` while it waits for a machine (`TaskExecutor.running`): its live row. */
   whereRunning?: (taskId: string) => string | null | undefined
+  /** A running task's live CPU and memory: its live row's `cpu` and `mem`. */
+  usage?: (taskId: string) => { cores: number; rssBytes: number } | undefined
+  /** Each task's count of the tasks downstream of it in the run, built on first ask: the rows' `blocks`. */
+  blocks?: () => ReadonlyMap<string, number>
   /** Worker-pool size for this run; shown on the `info` row. */
   concurrency?: number
   remoteCacheEnabled: boolean

package/src/util/colors.ts

@@ -12,6 +12,7 @@
 const RESET = '\x1b[0m'
 const BOLD = '\x1b[1m'
 const DIM = '\x1b[2m'
+const UNDERLINE = '\x1b[4m'
 
 // State hues every report shares with the run summary.
 export const SUCCESS = '#22c55e'
@@ -27,6 +28,7 @@ export interface ColorSupport {
 export interface PaintOptions {
   bold?: boolean
   dim?: boolean
+  underline?: boolean
 }
 
 /**
@@ -102,6 +104,7 @@ export function paint(
   let prefix = ''
   if (opts.bold) prefix += BOLD
   if (opts.dim) prefix += DIM
+  if (opts.underline) prefix += UNDERLINE
   if (color) prefix += ansiFor(color)
   if (prefix.length === 0) return text
   return `${prefix}${text}${RESET}`