@vzn/vx 0.0.649 → 0.0.651

package/src/report/framed-output.ts

@@ -26,49 +26,26 @@
 // `--ui=stream` mode.
 
 import { withForwardArgs } from '../exec/index.js'
-import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
+import { isCacheHit, isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
+import { formatElapsed, maskedCommand, printable } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import {
-  formatElapsed,
-  identityColor,
-  maskedCommand,
+  fileMemo,
+  hasEscape,
+  idParts,
+  lastRedraw,
+  leavesStyle,
+  linkPaths,
   paint,
-  printable,
   ruleWidth,
-  ui,
+  STYLE_END,
   type ColorSupport,
-} from '../util/index.js'
+  type Style,
+} from '../ui/index.js'
 import { neverStarted } from './summary.js'
 import { outcomeLabel, outcomeWord, ranNoCache, skippedReason } from './events.js'
-import { fileMemo, linkPaths } from './path-links.js'
 
 const NO_COLOR: ColorSupport = { enabled: false }
-// Ends any colour a task's output left on, so vx's own lines below never
-// take it (a task killed mid-write leaves one open).
-export const RESET = '\x1b[0m'
-
-/** Whether `text`'s last colour code sets a style rather than resetting it. */
-export function leavesStyle(text: string): boolean {
-  const at = text.lastIndexOf('\x1b[')
-  if (at < 0) return false
-  const sgr = /^\[([\d;]*)m/.exec(text.slice(at + 1, at + 64))
-  // Not a colour code (a cursor move): look no further, as a reset costs nothing.
-  if (sgr === null) return true
-  return sgr[1] !== '' && sgr[1] !== '0'
-}
-
-const ACCENT = '#06b6d4' // cyan-500 — bullets, remote-hit hint
-// Identity hues (`identityColor`) are outside the status palette (green /
-// red / yellow / cyan) so a task id can never read as an outcome. Each
-// half of an id hashes its own name: same project, same hue; same target,
-// same hue, in every run, list and region row.
-
-const SUCCESS = '#22c55e' // green-500 — success / fresh
-const WARN = '#eab308' // yellow-500 — skipped
-const ERROR = '#ef4444' // red-500 — failed
-const ABORTED = '#f97316' // orange-500 — killed by a shutdown signal
-const LOCAL = '#38bdf8' // sky-400 — local cache hit
-const REMOTE = '#2563eb' // blue-600 — remote cache hit
-
 /** A piece of a task's output, as written: `err` for stderr. */
 export interface OutputChunk {
   text: string
@@ -111,11 +88,11 @@ export function formatTaskBlock(
   const output = body.output ?? []
 
   const idPainted = paintTaskId(node, colors, { bold: true })
-  const corner = (s: string) => paint('', s, colors, { dim: true })
+  const corner = (s: string) => paint('muted', s, colors)
   // A ready server's frame reads as the live one does: marked, and running.
   const mark = persistentMark(node, colors)
   const running = mark !== '' && outcome.status === 'success' && outcome.serverExit === undefined
-  const header = running ? paint(ACCENT, 'running', colors) : formatBlockHeader(outcome, colors)
+  const header = running ? paint('info', 'running', colors) : formatBlockHeader(outcome, colors)
   const lines: string[] = [`${corner('┌─')} ${mark}${idPainted} ${corner('>')} ${header}`]
 
   // The command section shows what actually ran — executed tasks
@@ -149,9 +126,7 @@ export function formatTaskBlock(
 
 /** What a bounded capture dropped from its head, so a capped log never reads as whole. */
 function droppedNote(lost: number, colors: ColorSupport): string {
-  return paint('', `… ${lost} earlier character${lost === 1 ? '' : 's'} dropped`, colors, {
-    dim: true,
-  })
+  return paint('muted', `… ${lost} earlier character${lost === 1 ? '' : 's'} dropped`, colors)
 }
 
 /**
@@ -163,7 +138,7 @@ function pushStreamSection(
   lines: string[],
   text: string,
   title: string,
-  color: string,
+  color: Style,
   lost: number,
   colors: ColorSupport,
 ): void {
@@ -173,7 +148,7 @@ function pushStreamSection(
     lines.push(droppedNote(lost, colors))
   }
   pushBodyLines(lines, text)
-  if (leavesStyle(text)) lines.push(`${lines.pop()}${RESET}`)
+  if (leavesStyle(text)) lines.push(`${lines.pop()}${STYLE_END}`)
   lines.push('')
 }
 
@@ -193,7 +168,7 @@ function pushOutputSection(
   link?: (line: string) => string,
 ): void {
   if (output.every((c) => c.text.trim().length === 0)) return
-  lines.push(sectionLine('OUTPUT', '', colors), '')
+  lines.push(sectionLine('OUTPUT', 'strong', colors), '')
   if (lost > 0) {
     lines.push(droppedNote(lost, colors))
   }
@@ -216,10 +191,10 @@ function pushOutputSection(
   for (const l of body) {
     const text = link === undefined ? l.text : link(l.text)
     if (!l.err || !colors.enabled) lines.push(text)
-    else lines.push(l.text.includes('\x1b') ? text : paint(ERROR, text, colors))
+    else lines.push(hasEscape(l.text) ? text : paint('error', text, colors))
   }
-  const styled = output.findLast((c) => c.text.includes('\x1b['))
-  if (styled !== undefined && leavesStyle(styled.text)) lines.push(`${lines.pop()}${RESET}`)
+  const styled = output.findLast((c) => hasEscape(c.text))
+  if (styled !== undefined && leavesStyle(styled.text)) lines.push(`${lines.pop()}${STYLE_END}`)
   lines.push('')
 }
 
@@ -230,9 +205,9 @@ function pushOutputSection(
  * the frame width, and sections get vertical margins so content stands
  * clear of the furniture.
  */
-function sectionLine(title: string, color: string, colors: ColorSupport): string {
-  const corner = (s: string) => paint('', s, colors, { dim: true })
-  const label = paint(color, title, colors, { bold: true })
+function sectionLine(title: string, color: Style, colors: ColorSupport): string {
+  const corner = (s: string) => paint('muted', s, colors)
+  const label = paint(color, title, colors, true)
   // As wide as the footer's rule, so the frames and the footer line up.
   const rule = corner('─'.repeat(Math.max(1, ruleWidth(colors) - 4 - title.length)))
   return `${corner('├─')} ${label} ${rule}`
@@ -260,13 +235,7 @@ export function paintIdParts(
   colors: ColorSupport,
   opts: { bold?: boolean; sep?: '#' | ':' } = {},
 ): string {
-  const dim = (t: string) => paint('', t, colors, { dim: true })
-  const { sep = '#', ...style } = opts
-  return (
-    paint(identityColor(hueSource), projectText, colors, style) +
-    dim(sep) +
-    paint(identityColor(taskText), taskText, colors, style)
-  )
+  return idParts(hueSource, projectText, taskText, colors, opts)
 }
 
 function paintId(
@@ -292,16 +261,20 @@ 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
-/** The list header's colour: violet-400, the summary rule's first stop. */
-const HEADER = '#a78bfa'
+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 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
 
 /** Right-align the duration in a TIME_COL cell (pad on the left). */
 function timeCell(ms: number | null, colors: ColorSupport): string {
   let raw = ms === null ? '' : formatElapsed(ms)
   // `1000.00s` is wider than the cell; minutes fit it up to `99m 59s`.
   if (ms !== null && raw.length > TIME_COL) raw = formatElapsed(ms, true)
-  return ' '.repeat(Math.max(0, TIME_COL - raw.length)) + paint('', raw, colors, { dim: true })
+  // The time is the row's fact (value level); the cells around it are meta.
+  return ' '.repeat(Math.max(0, TIME_COL - raw.length)) + paint('value', raw, colors)
 }
 
 /**
@@ -309,13 +282,8 @@ function timeCell(ms: number | null, colors: ColorSupport): string {
  * An empty color string renders the text dim (used for the `miss` cache
  * word); empty text is a blank cell.
  */
-function cell(text: string, color: string, width: number, colors: ColorSupport): string {
-  const painted =
-    text === ''
-      ? ''
-      : color === ''
-        ? paint('', text, colors, { dim: true })
-        : paint(color, text, colors)
+function cell(text: string, color: Style | '', width: number, colors: ColorSupport): string {
+  const painted = text === '' ? '' : paint(color === '' ? 'muted' : color, text, colors)
   return painted + ' '.repeat(Math.max(0, width - text.length))
 }
 
@@ -338,34 +306,34 @@ function glyphShape(o: TaskOutcome): string {
 }
 
 /** Task-axis word + color (a cache hit is a success). */
-function statusOf(o: TaskOutcome): { word: string; color: string } {
+function statusOf(o: TaskOutcome): { word: string; color: Style } {
   switch (o.status) {
     case 'failed':
-      return { word: 'failed', color: ERROR }
+      return { word: 'failed', color: 'error' }
     case 'skipped':
-      return { word: 'skipped', color: WARN }
+      return { word: 'skipped', color: 'warn' }
     default:
-      return { word: 'success', color: SUCCESS }
+      return { word: 'success', color: 'ok' }
   }
 }
 
 /** Cache-axis word + color. Empty for states that never reached the cache. */
-function cacheOf(o: TaskOutcome): { word: string; color: string } {
+function cacheOf(o: TaskOutcome): { word: string; color: Style } {
   switch (o.status) {
     case 'success':
     case 'failed':
       // A task no cache answered for never consulted one: not a miss.
-      return { word: ranNoCache(o) ? 'no-cache' : 'miss', color: '' } // dim
+      return { word: ranNoCache(o) ? 'no-cache' : 'miss', color: 'muted' } // dim
     case 'cache-hit':
       return o.restored === false
-        ? { word: 'fresh', color: SUCCESS }
-        : { word: 'local', color: LOCAL }
+        ? { word: 'fresh', color: 'ok' }
+        : { word: 'local', color: 'local' }
     case 'cache-hit-remote':
       return o.restored === false
-        ? { word: 'fresh', color: SUCCESS }
-        : { word: 'remote', color: REMOTE }
+        ? { word: 'fresh', color: 'ok' }
+        : { word: 'remote', color: 'remote' }
     default:
-      return { word: '', color: '' }
+      return { word: '', color: 'muted' }
   }
 }
 
@@ -375,46 +343,282 @@ 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>
+ * <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,
   ms: number | null,
   status: string,
-  statusColor: string,
+  statusColor: Style | '',
   cache: string,
-  cacheColor: string,
+  cacheColor: Style | '',
   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
+  const usual = cells.usual ?? { text: '', painted: '' }
+  const us = `${' '.repeat(Math.max(0, USUAL_COL - usual.text.length))}${usual.painted}`
+  const cpu =
+    cells.cpu === undefined ? '' : cells.cpu === null ? UNKNOWN : `${Math.round(cells.cpu * 100)}%`
+  const mem =
+    cells.memBytes === undefined
       ? ''
-      : `${' '.repeat(Math.max(0, BLOCKED_COL - blocked.length))}${paint(WARN, blocked, colors)} `
-  return ` ${glyph} ${timeCell(ms, colors)} ${st} ${ca} ${bl}${paintedId}`
+      : cells.memBytes === null
+        ? UNKNOWN
+        : 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} ${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(blocks === '0' ? 'muted' : 'value', blocks, colors)} ` +
+    `${placeCell(worker, colors)}${' '.repeat(WORKER_COL - worker.length)} ${paintedId}`
+  )
+}
+
+/**
+ * A cell vx cannot know: a peak no look saw, a task history never timed.
+ * Blank is a cell that does not apply (a hit ran nothing).
+ */
+const UNKNOWN = '\u2014'
+
+/** A row's cells past time, status and cache; each blank when absent, `—` when null. */
+export interface RowCells {
+  /** After the time, pre-painted: `~18s` live, `+6.0s` / `−1.4s` after. */
+  usual?: { text: string; painted: string }
+  /** Cores in use (live) or on average (after): 1.8 prints `180%`. */
+  cpu?: number | null
+  /** Resident memory now (live) or at its peak (after). */
+  memBytes?: number | null
+  /** 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('muted', text, colors)
+}
+
+/** `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 run names a handful of workers over thousands of rows: each painted
+// once (escaping and painting per row was ~12 ms of a 9,603-task warm run).
+const placeCells = new WeakMap<ColorSupport, Map<string, string>>()
+
+function placeCell(worker: string, colors: ColorSupport): string {
+  if (worker === '') return ''
+  let byName = placeCells.get(colors)
+  if (byName === undefined) placeCells.set(colors, (byName = new Map()))
+  let painted = byName.get(worker)
+  if (painted === undefined) byName.set(worker, (painted = ui.inline(ui.place(worker), colors)))
+  return painted
+}
+
+/** 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
+}
+
+/** 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 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.
+ * The results list's `±usual` cell: how far an executed task ran from its
+ * usual time, `+6.0s` red or `−1.4s` green past a fifth of the usual either
+ * way, dim within it; `—` (null) with no history for the task, blank
+ * (undefined) with no history to ask. A blank within a fifth read as no
+ * usual at all (2026-10-29).
  */
-export function formatListHeader(
-  worker: boolean,
+export function usualCell(
+  ms: number,
+  usualMs: number | null | undefined,
   colors: ColorSupport = NO_COLOR,
-  blocked = false,
+): { text: string; painted: string } {
+  if (usualMs === undefined) return { text: '', painted: '' }
+  if (usualMs === null || usualMs <= 0) return unknownUsual(colors)
+  const d = ms - usualMs
+  const text = `${d >= 0 ? '+' : '\u2212'}${formatElapsed(Math.abs(d), true)}`
+  if (Math.abs(d) <= usualMs * 0.2) return { text, painted: paint('muted', text, colors) }
+  return { text, painted: paint(d > 0 ? 'error' : 'ok', text, colors) }
+}
+
+/** The `usual` cell of a task history has never timed. */
+export function unknownUsual(colors: ColorSupport = NO_COLOR): { text: string; painted: string } {
+  return { text: UNKNOWN, painted: paint('muted', UNKNOWN, 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)} ` +
+    `${'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('label', head, colors)
+}
+
+/**
+ * The task list on its grid, under its header: the run's results panel's
+ * body, and `vx last`'s, so a replay reads as the run did.
+ */
+export function taskList(rows: readonly ((colors: ColorSupport) => string)[]): ui.Block {
+  return { lines: (c) => [formatListHeader(c), ...rows.map((row) => row(c))] }
+}
+
+/** What history keeps of a task's row: `vx last` draws it again from this. */
+export interface RecordedRow {
+  project: string
+  task: string
+  status: string
+  durationMs: number
+  restored: boolean | null
+  cached: boolean | null
+  cpuMs: number | null
+  peakRssBytes: number | null
+  placement: string | null
+  outputBytes: number | null
+  blocks: number | null
+}
+
+/**
+ * A recorded task's row, as the run printed it; `note` (dim) after its id.
+ * `usualMs` is the task's usual time now, from history (`null`: never timed).
+ */
+export function formatRecordedRow(
+  r: RecordedRow,
+  colors: ColorSupport = NO_COLOR,
+  note = '',
+  usualMs?: number | null,
 ): 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 })
+  // The row functions read a node's names and whether it declared a cache.
+  const node = {
+    id: `${r.project}#${r.task}`,
+    projectName: r.project,
+    taskName: r.task,
+    config: r.cached === false ? {} : { cache: {} },
+  } as unknown as TaskNode
+  const o = {
+    node,
+    status: r.status,
+    durationMs: r.durationMs,
+    ...(r.restored !== null ? { restored: r.restored } : {}),
+    ...(r.cpuMs !== null ? { cpuMs: r.cpuMs } : {}),
+    ...(r.peakRssBytes !== null ? { peakRssBytes: r.peakRssBytes } : {}),
+    ...(r.placement !== null ? { where: r.placement } : {}),
+    ...(r.outputBytes !== null ? { outputBytes: r.outputBytes } : {}),
+  } as TaskOutcome
+  const blocks = r.blocks ?? undefined
+  const row =
+    o.status === 'skipped'
+      ? formatTaskSkippedLine(node, colors, undefined, blocks)
+      : o.status === 'aborted'
+        ? formatTaskAbortedLine(node, o, colors, blocks)
+        : isCacheHit(o.status)
+          ? formatTaskHitLine(node, o, colors, false, blocks)
+          : formatTaskExecutedLine(node, o, colors, false, blocks, usualMs)
+  return note === '' ? row : `${row}  ${paint('muted', note, colors)}`
+}
+
+/**
+ * A running task's usual duration, fixed while the elapsed time counts up
+ * toward it (2026-10-14): `~5.2s`, `~42s`, `~2m 05s`. Fits the cache
+ * column below 100 minutes.
+ */
+export function formatExpected(ms: number): string {
+  // 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`
+  return `~${Math.floor(s / 60)}m ${String(s % 60).padStart(2, '0')}s`
+}
+
+/** A task `--dry` lists: what the run would do with it, on the running list's grid. */
+export interface PlannedRow {
+  node: TaskNode
+  glyph: string
+  status: string
+  /** The glyph's and the status word's hue. */
+  tone: Style
+  cache: string
+  cacheTone: Style | ''
+  /** Its usual time, from history. */
+  usualMs?: number
+  /** What a remote hit would download. */
+  outputBytes?: number
+  /** How many tasks are downstream of it. */
+  blocks?: number
+  worker: string
+  /** Dim, after the id: its description, why it is affected. */
+  note: string
+}
+
+/** `--dry`'s list: the running list's header and grid, so a plan reads as the run would. */
+export function planList(rows: readonly PlannedRow[]): ui.Block {
+  return {
+    lines: (c) => [
+      formatRunningHeader(c),
+      ...rows.map((r) => {
+        const usual = r.usualMs === undefined ? undefined : formatExpected(r.usualMs)
+        const row = formatTaskRow(
+          paint(r.tone, r.glyph, c),
+          null,
+          r.status,
+          r.tone,
+          r.cache,
+          r.cacheTone,
+          paintTaskId(r.node, c),
+          c,
+          {
+            ...(usual !== undefined
+              ? { usual: { text: usual, painted: paint('muted', usual, c) } }
+              : {}),
+            ...(r.outputBytes !== undefined ? { outputBytes: r.outputBytes } : {}),
+            ...(r.blocks !== undefined ? { blocks: String(r.blocks) } : {}),
+            worker: r.worker,
+          },
+        )
+        return r.note === '' ? row : `${row}  ${paint('muted', r.note, c)}`
+      }),
+    ],
+  }
 }
 
 /** Compact one-liner for a cache hit with nothing to replay. */
@@ -423,8 +627,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),
+  })
 }
 
 /**
@@ -437,8 +644,8 @@ export function formatTaskHashLine(
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
 ): string {
-  const color = o.status === 'aborted' ? ABORTED : statusOf(o).color
-  const key = o.hash === undefined ? '' : ` ${paint('', o.hash, colors, { dim: true })}`
+  const color = o.status === 'aborted' ? 'aborted' : statusOf(o).color
+  const key = o.hash === undefined ? '' : ` ${paint('muted', o.hash, colors)}`
   return `${paint(color, outcomeWord(o), colors)} ${paintTaskId(node, colors)}${key}`
 }
 
@@ -448,8 +655,44 @@ export function formatTaskExecutedLine(
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
   onPath = false,
+  blocks?: number,
+  usualMs?: number | null,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath, {
+    ...executedCells(o, blocks),
+    // A hit's time is a restore's, not the task's: nothing to compare.
+    ...(o.status === 'success' || o.status === 'failed'
+      ? { usual: usualCell(o.durationMs, usualMs, colors) }
+      : {}),
+  })
+}
+
+/**
+ * An executed task's cells: where it ran, its average cores and peak
+ * memory; a task that ran with either unread shows `—`, a hit nothing.
+ */
+export function executedCells(o: TaskOutcome, blocks: number | undefined): RowCells {
+  const cores = coresOf(o)
+  const ran = o.status === 'success' || o.status === 'failed'
+  return {
+    ...ranCells(o, blocks),
+    ...(cores !== undefined ? { cpu: cores } : ran ? { cpu: null } : {}),
+    ...(o.peakRssBytes !== undefined
+      ? { memBytes: o.peakRssBytes }
+      : ran
+        ? { memBytes: null }
+        : {}),
+  }
+}
+
+/** 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) } : {}),
+    ...(o.outputBytes !== undefined ? { outputBytes: o.outputBytes } : {}),
+  }
 }
 
 /** Shared: render any outcome on the grid. */
@@ -459,6 +702,7 @@ function formatOutcomeRow(
   ms: number | null,
   colors: ColorSupport,
   onPath: boolean,
+  cells: RowCells,
 ): string {
   const st = statusOf(o)
   const ca = cacheOf(o)
@@ -472,20 +716,21 @@ function formatOutcomeRow(
       ca.color,
       paintedId,
       colors,
+      cells,
     ) +
     (onPath ? pathNote(colors) : '') +
-    whereNote(o, colors) +
     flakyNote(o, colors)
   )
 }
 
 /** `critical path`: the row's task held the run's end while others ran beside it. */
 export function pathNote(colors: ColorSupport = NO_COLOR): string {
-  return `  ${paint(ERROR, 'critical path', colors)}`
+  // A fact worth knowing, not a failure: never red.
+  return `  ${paint('info', 'critical path', colors)}`
 }
 
 /** 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,8 +738,8 @@ 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 {
-  return `${paint('', ' \u00b7', colors, { dim: true })} ${ui.inline(ui.place(where), colors)}`
+function placeNote(where: string, colors: ColorSupport = NO_COLOR): string {
+  return `${paint('muted', ' \u00b7', colors)} ${ui.inline(ui.place(where), colors)}`
 }
 
 /**
@@ -512,7 +757,7 @@ export function flakyNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): stri
   }
   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 })}`
+  return ` ${paint('muted', text, colors)}`
 }
 
 /**
@@ -524,19 +769,21 @@ 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 })}`
+  const suffix = why === '' ? '' : ` ${paint('muted', `• ${why}`, colors)}`
   return (
     formatTaskRow(
-      paint(WARN, '\u2298', colors),
+      paint('warn', '\u2298', colors),
       null,
       'skipped',
-      WARN,
+      'warn',
       '',
       '',
       paintTaskId(node, colors),
       colors,
+      blocks === undefined ? {} : { blocks: String(blocks) },
     ) + suffix
   )
 }
@@ -550,11 +797,13 @@ 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 }),
+      paint('muted', '\u25cc', colors),
       null,
       'not run',
       '',
@@ -562,17 +811,19 @@ export function formatTaskAbortedLine(
       '',
       id,
       colors,
+      bl,
     )
   }
   return formatTaskRow(
-    paint(ABORTED, '\u2717', colors),
+    paint('aborted', '\u2717', colors),
     o.durationMs,
     'aborted',
-    ABORTED,
+    'aborted',
     '',
     '',
     id,
     colors,
+    ranCells(o, blocks),
   )
 }
 
@@ -588,7 +839,7 @@ export function formatFrameOpen(
   colors: ColorSupport = NO_COLOR,
   forwardArgs: readonly string[] = [],
 ): string {
-  const corner = (t: string) => paint('', t, colors, { dim: true })
+  const corner = (t: string) => paint('muted', t, colors)
   const cmd = shownCommand(node, forwardArgs)
   const mark = persistentMark(node, colors)
   return `${corner('┌─')} ${mark}${paintTaskId(node, colors, { bold: true })} ${corner('>')} $ ${cmd}`
@@ -620,7 +871,7 @@ function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[]
   // glob matches and the user decides.
   const fix = outcome.sandboxFix
   const line = fix === undefined ? undefined : sandboxFixLine(fix)
-  const dim = (text: string): string => paint('', text, colors, { dim: true })
+  const dim = (text: string): string => paint('muted', text, colors)
   const note =
     fix === undefined
       ? []
@@ -645,7 +896,7 @@ function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[]
   // vx's own notes (`vx: …`) explain a failure; they are not denials.
   const denials = body.filter((l) => !l.startsWith('vx: ')).length
   return [
-    sectionLine(denials > 0 ? `SANDBOX VIOLATIONS (${denials})` : 'SANDBOX', ERROR, colors),
+    sectionLine(denials > 0 ? `SANDBOX VIOLATIONS (${denials})` : 'SANDBOX', 'error', colors),
     '',
     ...body,
     '',
@@ -658,7 +909,7 @@ export function formatFrameClose(
   outcome: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
 ): string {
-  const corner = (t: string) => paint('', t, colors, { dim: true })
+  const corner = (t: string) => paint('muted', t, colors)
   const mark = persistentMark(node, colors)
   // A persistent task's child keeps running past this "ready" outcome,
   // so the close reads `running` (accent), not `success` — the ▸ marks
@@ -682,11 +933,11 @@ function shownCommand(node: TaskNode, forwardArgs: readonly string[]): string {
 }
 
 function persistentMark(node: TaskNode, colors: ColorSupport): string {
-  return node.config.exec?.persistent !== undefined ? `${paint(ACCENT, '▸', colors)} ` : ''
+  return node.config.exec?.persistent !== undefined ? `${paint('info', '▸', colors)} ` : ''
 }
 
 function runningFooter(o: TaskOutcome, colors: ColorSupport): string {
-  return ` ${paint('', `(${formatElapsed(o.durationMs)})`, colors, { dim: true })} ${paint(ACCENT, 'running', colors)}`
+  return ` ${paint('muted', `(${formatElapsed(o.durationMs)})`, colors)} ${paint('info', 'running', colors)}`
 }
 
 /**
@@ -713,8 +964,8 @@ export function formatPersistentTailBlock(
   const stderr = body.stderr ?? ''
   if (stdout.trim().length === 0 && stderr.trim().length === 0) return ''
   const lines: string[] = [formatFrameOpen(node, colors, forwardArgs)]
-  pushStreamSection(lines, stdout, 'STDOUT (since ready)', SUCCESS, dropped.stdout ?? 0, colors)
-  pushStreamSection(lines, stderr, 'STDERR (since ready)', ERROR, dropped.stderr ?? 0, colors)
+  pushStreamSection(lines, stdout, 'STDOUT (since ready)', 'ok', dropped.stdout ?? 0, colors)
+  pushStreamSection(lines, stderr, 'STDERR (since ready)', 'error', dropped.stderr ?? 0, colors)
   lines.push(formatFrameClose(node, outcome, colors))
   return lines.join('\n') + '\n'
 }
@@ -725,40 +976,16 @@ export function formatPersistentTailBlock(
  * logs read apart. `text` holds whole lines, its last newline cut off.
  */
 export function formatKeptLines(node: TaskNode, text: string, colors: ColorSupport): string {
-  const prefix = `${paintTaskId(node, colors)} ${paint('', '│', colors, { dim: true })} `
+  const prefix = `${paintTaskId(node, colors)} ${paint('muted', '│', colors)} `
   return text
     .split('\n')
     .map((line) => {
       const shown = lastRedraw(line)
-      return `${prefix}${shown}${leavesStyle(shown) ? RESET : ''}\n`
+      return `${prefix}${shown}${leavesStyle(shown) ? STYLE_END : ''}\n`
     })
     .join('')
 }
 
-// eslint-disable-next-line no-control-regex -- ESC is the point
-const LINE_RESET = /\r|\x1b\[[12]K|\x1b\[[01]?G/g
-// eslint-disable-next-line no-control-regex -- ESC is the point
-const TRAILING_RESETS = /(?:\r|\x1b\[[12]K|\x1b\[[01]?G)+$/
-// eslint-disable-next-line no-control-regex -- ESC is the point
-const SGR = /\x1b\[[0-9;]*m/g
-
-/**
- * What a line shows once its redraws have played: the text after its last
- * `\r`, line erase (`CSI 1K`/`2K`) or move to column 1 (`CSI G`), with the
- * colours set before it. Written after an id prefix, a dev server's redraw
- * (`\x1b[2K\x1b[1Gbuilt in 30ms`, a `10%\r100%` progress line) erased or
- * overwrote the prefix on a terminal. A reset that ends the line, as in
- * CRLF, redraws nothing.
- */
-function lastRedraw(line: string): string {
-  if (!line.includes('\r') && !line.includes('\x1b')) return line
-  const text = line.replace(TRAILING_RESETS, '')
-  let cut = -1
-  for (const m of text.matchAll(LINE_RESET)) cut = m.index + m[0].length
-  if (cut === -1) return text
-  return (text.slice(0, cut).match(SGR) ?? []).join('') + text.slice(cut)
-}
-
 /**
  * Between the requested task's frame and the summary footer, list the
  * persistent tasks (dev servers / watchers) the run is keeping alive in
@@ -772,28 +999,28 @@ export function formatPersistentList(
 ): string[] {
   return nodes.map(
     (n) =>
-      `  ${paint(ACCENT, '▸', colors)} ${paintTaskId(n, colors)} ${paint('', 'running', colors, { dim: true })}`,
+      `  ${paint('info', '▸', colors)} ${paintTaskId(n, colors)} ${paint('muted', 'running', colors)}`,
   )
 }
 
 function formatBlockHeader(o: TaskOutcome, colors: ColorSupport): string {
   const shortHash = o.hash ? o.hash.slice(0, 8) : ''
-  const dim = (s: string) => paint('', s, colors, { dim: true })
+  const dim = (s: string) => paint('muted', s, colors)
   const word = outcomeLabel(o)
   switch (o.status) {
     case 'cache-hit':
-      return `${paint(SUCCESS, word, colors)} ${dim(`• ${shortHash}`)}`
+      return `${paint('ok', word, colors)} ${dim(`• ${shortHash}`)}`
     case 'cache-hit-remote':
       // A remote restore is the one hit painted accent: bytes came off the wire.
-      return `${paint(o.restored === false ? SUCCESS : ACCENT, word, colors)} ${dim(`• ${shortHash}`)}`
+      return `${paint(o.restored === false ? 'ok' : 'info', word, colors)} ${dim(`• ${shortHash}`)}`
     case 'failed':
       // The command lives in its own `├─ command` section; the header
       // carries the outcome like every other status.
-      return paint(ERROR, word, colors, { bold: true })
+      return paint('error', word, colors, true)
     case 'skipped':
-      return paint(WARN, word, colors)
+      return paint('warn', word, colors)
     case 'aborted':
-      return paint(ABORTED, word, colors)
+      return paint('aborted', word, colors)
     default:
       return dim(word)
   }
@@ -807,7 +1034,7 @@ function formatBlockFooter(o: TaskOutcome, colors: ColorSupport): string {
   // saved" on the strength of it. The stored time lives on
   // `TaskOutcome.storedDurationMs`.) Status differs by outcome — see
   // formatStatusTag.
-  const dur = paint('', `(${formatElapsed(o.durationMs)})`, colors, { dim: true })
+  const dur = paint('muted', `(${formatElapsed(o.durationMs)})`, colors)
   const tag = formatStatusTag(o, colors)
   return ` ${dur} ${tag}${flakyNote(o, colors)}`
 }
@@ -816,13 +1043,13 @@ function formatStatusTag(o: TaskOutcome, colors: ColorSupport): string {
   const word = outcomeLabel(o)
   switch (o.status) {
     case 'failed':
-      return paint(ERROR, word, colors, { bold: true })
+      return paint('error', word, colors, true)
     case 'skipped':
-      return paint(WARN, word, colors)
+      return paint('warn', word, colors)
     case 'aborted':
-      return paint(ABORTED, word, colors)
+      return paint('aborted', word, colors)
     default:
-      return paint('', word, colors, { dim: true })
+      return paint('muted', word, colors)
   }
 }