@vzn/vx 0.0.652 → 0.0.653

package/src/report/framed-output.ts

@@ -26,11 +26,18 @@
 // `--ui=stream` mode.
 
 import { withForwardArgs } from '../exec/index.js'
-import { isCacheHit, isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
+import {
+  isCacheHit,
+  isGroupTask,
+  isKeyFailed,
+  type TaskNode,
+  type TaskOutcome,
+} from '../graph/index.js'
 import { formatElapsed, maskedCommand, printable } from '../util/index.js'
 import * as ui from '../ui/index.js'
 import {
   fileMemo,
+  GUTTER,
   hasEscape,
   idParts,
   lastRedraw,
@@ -99,7 +106,7 @@ export function formatTaskBlock(
   // (success and failed). Cache hits normally skip it (the stored
   // output is the interesting part), but `forceCommand` keeps it for
   // focused requested tasks so their frame is hit/miss-identical.
-  if (forceCommand || outcome.status === 'success' || outcome.status === 'failed') {
+  if (forceCommand || ranCommand(outcome)) {
     // No section label for the command (owner cut it) — the dim `$ `
     // line under the header reads as the command on its own.
     lines.push('', corner(`$ ${shownCommand(node, forwardArgs)}`), '')
@@ -120,8 +127,10 @@ export function formatTaskBlock(
 
   lines.push(
     `${corner('└─')} ${mark}${idPainted}${whereNote(outcome, colors)} ${corner('──')}${running ? runningFooter(outcome, colors) : formatBlockFooter(outcome, colors)}`,
+    '',
   )
-  return lines.join('\n') + '\n'
+  // Not `+ '\n'`: a rope over a 100 MB frame was flattened into a copy.
+  return lines.join('\n')
 }
 
 /** What a bounded capture dropped from its head, so a capped log never reads as whole. */
@@ -172,27 +181,41 @@ function pushOutputSection(
   if (lost > 0) {
     lines.push(droppedNote(lost, colors))
   }
-  const body: Array<{ text: string; err: boolean }> = []
+  const emit = (line: string, err: boolean): void => {
+    const text = link === undefined ? line : link(line)
+    if (!err || !colors.enabled) lines.push(text)
+    else lines.push(hasEscape(line) ? text : paint('error', text, colors))
+  }
+  // A run of whole lines nothing restyles is pushed as one slice, its
+  // newlines inside: an object and a string per line peaked a 50 MB log's
+  // frame at ~11x its size.
   let open: { parts: string[]; err: boolean } | null = null
   for (const c of output) {
-    let rest = c.text
-    while (rest.length > 0) {
-      const nl = rest.indexOf('\n')
-      const piece = nl < 0 ? rest : rest.slice(0, nl)
-      if (open === null) open = { parts: [], err: c.err }
-      open.parts.push(piece)
-      if (nl < 0) break
-      body.push({ text: open.parts.join(''), err: open.err })
+    const text = c.text
+    let at = 0
+    if (open !== null) {
+      const nl = text.indexOf('\n')
+      open.parts.push(nl < 0 ? text : text.slice(0, nl))
+      if (nl < 0) continue
+      emit(open.parts.join(''), open.err)
       open = null
-      rest = rest.slice(nl + 1)
+      at = nl + 1
     }
+    if (link === undefined && (!c.err || !colors.enabled)) {
+      const last = text.lastIndexOf('\n')
+      if (last >= at) {
+        lines.push(text.slice(at, last))
+        at = last + 1
+      }
+    } else {
+      for (let nl = text.indexOf('\n', at); nl >= 0; nl = text.indexOf('\n', at)) {
+        emit(text.slice(at, nl), c.err)
+        at = nl + 1
+      }
+    }
+    if (at < text.length) open = { parts: [text.slice(at)], err: c.err }
   }
-  if (open !== null) body.push({ text: open.parts.join(''), err: open.err })
-  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(hasEscape(l.text) ? text : paint('error', text, colors))
-  }
+  if (open !== null) emit(open.parts.join(''), open.err)
   const styled = output.findLast((c) => hasEscape(c.text))
   if (styled !== undefined && leavesStyle(styled.text)) lines.push(`${lines.pop()}${STYLE_END}`)
   lines.push('')
@@ -251,14 +274,13 @@ function paintTaskId(node: TaskNode, colors: ColorSupport, opts: { bold?: boolea
   return paintId(node.projectName, node.taskName, colors, opts)
 }
 
-// ── Reported-line grid: glyph · time · status · cache · name ────────
-// glyph SHAPE encodes the cache axis (⏺ miss · ► fresh · ⇢ local · ⇣
-// remote; ◼ failed · ⊘ skipped · ✗ aborted · ◌ not run), glyph COLOR encodes the
-// task axis (green/red/yellow/cyan). The status and cache WORDS spell
-// the two axes out, each in its own color. Time is right-aligned in a
+// ── Reported-line grid: status · cache · usual · time · … · name ────────
+// No glyph (2026-11-06): the status word, first at the Summary's value
+// column, is the task axis and the cache word the cache axis, each in
+// its own color. Time is right-aligned in a
 // fixed cell so durations line up and a ticking elapsed never shifts
 // the row. All detail (exit code, output) lives in the framed block.
-export const TIME_COL = 7 // "0ms" … "999.99s", then "16m 40s" … "99m 59s"
+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 // `blocks`: how many tasks are downstream of the row's
@@ -279,7 +301,8 @@ function pad(n: number): string {
 
 /** 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)
+  if (ms === null) return pad(TIME_COL - 1) + paint('muted', UNKNOWN, colors)
+  let raw = 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)
   // The time is the row's fact (value level); the cells around it are meta.
@@ -296,24 +319,6 @@ function cell(text: string, color: Style | '', width: number, colors: ColorSuppo
   return painted + pad(width - text.length)
 }
 
-/** The cache-shape glyph (task-shape for non-success). */
-function glyphShape(o: TaskOutcome): string {
-  switch (o.status) {
-    case 'success':
-      return '⏺\uFE0E' // ⏺ miss (ran), text-presentation (narrow)
-    case 'cache-hit':
-      return o.restored === false ? '\u25ba' : '\u21e2' // ► fresh : ⇢ local
-    case 'cache-hit-remote':
-      return o.restored === false ? '\u25ba' : '\u21e3' // ► fresh : ⇣ remote
-    case 'failed':
-      return '\u25fc\uFE0E' // ◼ failed, text-presentation (narrow)
-    case 'skipped':
-      return '\u2298' // ⊘ skipped
-    default:
-      return '⏺\uFE0E'
-  }
-}
-
 /** Task-axis word + color (a cache hit is a success). */
 function statusOf(o: TaskOutcome): { word: string; color: Style } {
   switch (o.status) {
@@ -326,8 +331,19 @@ function statusOf(o: TaskOutcome): { word: string; color: Style } {
   }
 }
 
-/** Cache-axis word + color. Empty for states that never reached the cache. */
+/** Whether the task ran its command: a hit whose restore failed did not, nor a task with no key. */
+function ranCommand(o: TaskOutcome): boolean {
+  return (
+    o.status === 'success' || (o.status === 'failed' && o.restoreFailed !== true && !isKeyFailed(o))
+  )
+}
+
+/**
+ * Cache-axis word + color. Empty for states that never reached the cache,
+ * a hit whose restore failed (neither a miss nor a hit) and a task with no key.
+ */
 function cacheOf(o: TaskOutcome): { word: string; color: Style } {
+  if (o.restoreFailed === true || isKeyFailed(o)) return { word: '', color: 'muted' }
   switch (o.status) {
     case 'success':
     case 'failed':
@@ -346,20 +362,14 @@ function cacheOf(o: TaskOutcome): { word: string; color: Style } {
   }
 }
 
-/** The painted status glyph (shape = cache axis, color = task axis). */
-function taskGlyph(o: TaskOutcome, colors: ColorSupport): string {
-  return paint(statusOf(o).color, glyphShape(o), colors)
-}
-
 /**
- * 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
+ * One reported task row on the list grid: `<status> <cache> <usual>
+ * <time> <cpu> <mem> <outputs> <blocks> <worker> <mark> <name>`, the status at
+ * the Summary's value column, no glyph (2026-11-06). 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: Style | '',
@@ -369,35 +379,43 @@ export function formatTaskRow(
   colors: ColorSupport = NO_COLOR,
   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 usual = cells.usual ?? { text: '', painted: '' }
+  // Every cell says something: one with nothing in it reads `—` (2026-11-06).
+  const st = cell(status || UNKNOWN, statusColor, STATUS_COL, colors)
+  // `aborting` runs one into the cache cell.
+  const ca = cell(
+    cache || UNKNOWN,
+    cache === '' ? '' : cacheColor,
+    CACHE_COL - Math.max(0, status.length - STATUS_COL),
+    colors,
+  )
+  const usual =
+    cells.usual === undefined || cells.usual.text === '' ? unknownUsual(colors) : cells.usual
   const us = `${pad(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
-      ? ''
-      : cells.memBytes === null
-        ? UNKNOWN
-        : formatSize(cells.memBytes)
-  const out = cells.outputBytes === undefined ? '' : formatSize(cells.outputBytes)
-  const blocks = cells.blocks ?? ''
-  const worker = workerName(cells.worker ?? '')
+  const cpu = cells.cpu == null ? UNKNOWN : `${Math.round(cells.cpu * 100)}%`
+  const mem = cells.memBytes == null ? UNKNOWN : formatSize(cells.memBytes)
+  const out = cells.outputBytes == null ? UNKNOWN : formatSize(cells.outputBytes)
+  const blocks = cells.blocks || UNKNOWN
+  const worker = workerName(cells.worker || UNKNOWN)
   return (
-    ` ${glyph} ${timeCell(ms, colors)} ${us} ${st} ${ca} ` +
+    `${ROW_LEAD}${st} ${ca} ${us} ${timeCell(ms, colors)} ` +
     `${right(cpu, CPU_COL, colors)} ${right(mem, MEM_COL, colors)} ${right(out, OUT_COL, colors)} ` +
-    `${pad(BLOCKED_COL - blocks.length)}${paint(blocks === '0' ? 'muted' : 'value', blocks, colors)} ` +
-    `${placeCell(worker, colors)}${pad(WORKER_COL - worker.length)} ${paintedId}`
+    `${pad(BLOCKED_COL - blocks.length)}${paint(blocks === '0' || blocks === UNKNOWN ? 'muted' : 'value', blocks, colors)} ` +
+    `${placeCell(worker, colors)}${pad(WORKER_COL - worker.length)} ` +
+    `${cells.critical === true ? paint('warn', CRITICAL_MARK, colors) : ' '} ${paintedId}`
   )
 }
 
+/** A cell with nothing in it: unknown, or not applying to the row (a hit ran nothing). */
+const UNKNOWN = '\u2014'
+
 /**
- * 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).
+ * The critical path's mark, before the task's name: the row's task held the
+ * run's end while others ran beside it. One glyph, yellow (2026-11-06).
  */
-const UNKNOWN = '\u2014'
+const CRITICAL_MARK = '\u25c6'
+
+/** A grid row's lead: the gutter, so a row starts where a field's value does. */
+const ROW_LEAD = ' '.repeat(GUTTER)
 
 /** A row's cells past time, status and cache; each blank when absent, `—` when null. */
 export interface RowCells {
@@ -408,11 +426,13 @@ export interface RowCells {
   /** 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
+  outputBytes?: number | null
   /** How many tasks are downstream. */
   blocks?: string
   /** The machine it runs or ran on: `local`, or the executor's name for it. */
   worker?: string
+  /** On the critical path: `◆` before the task's name. */
+  critical?: boolean
 }
 
 function right(text: string, width: number, colors: ColorSupport): string {
@@ -435,7 +455,7 @@ export function formatSize(bytes: number): string {
 const placeCells = new WeakMap<ColorSupport, Map<string, string>>()
 
 function placeCell(worker: string, colors: ColorSupport): string {
-  if (worker === '') return ''
+  if (worker === UNKNOWN) return paint('muted', UNKNOWN, colors)
   let byName = placeCells.get(colors)
   if (byName === undefined) placeCells.set(colors, (byName = new Map()))
   let painted = byName.get(worker)
@@ -497,10 +517,10 @@ export function formatRunningHeader(colors: ColorSupport = NO_COLOR): string {
 
 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)
+    `${'status'.padEnd(STATUS_COL)} ${'cache'.padEnd(CACHE_COL)} ${usual.padStart(USUAL_COL)} ` +
+    `${'time'.padStart(TIME_COL)} ${'cpu'.padStart(CPU_COL)} ` +
+    `${'mem'.padStart(MEM_COL)} ${'outputs'.padStart(OUT_COL)} ${'blocks'.padStart(BLOCKED_COL)} ${'worker'.padEnd(WORKER_COL)}   task`
+  return paint('muted', head, colors)
 }
 
 /**
@@ -508,7 +528,7 @@ function header(usual: string, colors: ColorSupport): string {
  * 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))] }
+  return { head: formatListHeader, lines: (c) => rows.map((row) => row(c)) }
 }
 
 /** What history keeps of a task's row: `vx last` draws it again from this. */
@@ -517,6 +537,8 @@ export interface RecordedRow {
   task: string
   status: string
   durationMs: number
+  /** Null on a cached task's failure: its hit's restore failed. */
+  cacheHit: boolean | null
   restored: boolean | null
   cached: boolean | null
   cpuMs: number | null
@@ -547,6 +569,9 @@ export function formatRecordedRow(
     node,
     status: r.status,
     durationMs: r.durationMs,
+    ...(r.status === 'failed' && r.cached === true && r.cacheHit === null
+      ? { restoreFailed: true }
+      : {}),
     ...(r.restored !== null ? { restored: r.restored } : {}),
     ...(r.cpuMs !== null ? { cpuMs: r.cpuMs } : {}),
     ...(r.peakRssBytes !== null ? { peakRssBytes: r.peakRssBytes } : {}),
@@ -582,14 +607,13 @@ export function formatExpected(ms: number): string {
 /** 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. */
+  /** The status word's hue. */
   tone: Style
   cache: string
   cacheTone: Style | ''
-  /** Its usual time, from history. */
-  usualMs?: number
+  /** Its usual time, from history; null for a task that runs and history never timed. */
+  usualMs?: number | null
   /** What a remote hit would download. */
   outputBytes?: number
   /** How many tasks are downstream of it. */
@@ -602,12 +626,16 @@ export interface PlannedRow {
 /** `--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)
+    head: formatRunningHeader,
+    lines: (c) =>
+      rows.map((r) => {
+        const usual =
+          r.usualMs === undefined
+            ? undefined
+            : r.usualMs === null
+              ? UNKNOWN
+              : formatExpected(r.usualMs)
         const row = formatTaskRow(
-          paint(r.tone, r.glyph, c),
           null,
           r.status,
           r.tone,
@@ -626,7 +654,6 @@ export function planList(rows: readonly PlannedRow[]): ui.Block {
         )
         return r.note === '' ? row : `${row}  ${paint('muted', r.note, c)}`
       }),
-    ],
   }
 }
 
@@ -638,9 +665,14 @@ export function formatTaskHitLine(
   onPath = false,
   blocks?: number,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath, {
-    ...ranCells(o, blocks),
-  })
+  return formatOutcomeRow(
+    o,
+    paintTaskId(node, colors),
+    o.durationMs,
+    colors,
+    onPath,
+    ranCells(o, blocks),
+  )
 }
 
 /**
@@ -667,13 +699,10 @@ export function formatTaskExecutedLine(
   blocks?: number,
   usualMs?: number | null,
 ): string {
-  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) }
-      : {}),
-  })
+  const cells = executedCells(o, blocks)
+  // A hit's time is a restore's, not the task's: nothing to compare.
+  if (ranCommand(o)) cells.usual = usualCell(o.durationMs, usualMs, colors)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath, cells)
 }
 
 /**
@@ -682,26 +711,28 @@ export function formatTaskExecutedLine(
  */
 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 }
-        : {}),
-  }
+  const ran = ranCommand(o)
+  const cells = ranCells(o, blocks)
+  if (cores !== undefined) cells.cpu = cores
+  else if (ran) cells.cpu = null
+  if (o.peakRssBytes !== undefined) cells.memBytes = o.peakRssBytes
+  else if (ran) cells.memBytes = null
+  return cells
 }
 
-/** The cells every row of a task that reached a machine carries. */
+/**
+ * The cells every row of a task that reached a machine carries. Assigned,
+ * not spread: a warm run builds one per hit, and the spreads, copied again
+ * by the caller, were ~4 ms of 8,002 hits' rows (2026-11-07).
+ */
 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 } : {}),
-  }
+  const cells: RowCells = {}
+  // A skip reached no machine.
+  if (o.status !== 'skipped') cells.worker = o.where ?? 'local'
+  if (blocks !== undefined) cells.blocks = String(blocks)
+  // A row with no outputs size says so (`—`); blank read as a column left out.
+  if (o.status !== 'skipped') cells.outputBytes = o.outputBytes ?? null
+  return cells
 }
 
 /** Shared: render any outcome on the grid. */
@@ -717,7 +748,6 @@ function formatOutcomeRow(
   const ca = cacheOf(o)
   return (
     formatTaskRow(
-      taskGlyph(o, colors),
       ms,
       st.word,
       st.color,
@@ -725,19 +755,11 @@ function formatOutcomeRow(
       ca.color,
       paintedId,
       colors,
-      cells,
-    ) +
-    (onPath ? pathNote(colors) : '') +
-    flakyNote(o, colors)
+      onPath ? { ...cells, critical: true } : cells,
+    ) + 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 {
-  // 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). */
 function whereNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): string {
   return o.where === undefined ? '' : placeNote(o.where, colors)
@@ -754,10 +776,14 @@ function placeNote(where: string, colors: ColorSupport = NO_COLOR): string {
 /**
  * The dim note a flaky task's row and frame carry (`flaky - failed 1×
  * before`): nothing prints below the footer, so the task's own line is
- * where the reader learns it. '' when the run did not prove it flaky.
+ * where the reader learns it. Not proved flaky: its attempts, when more
+ * than one; else ''.
  */
 export function flakyNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): string {
-  if (o.flaky === undefined) return ''
+  // A retry with no key to prove a flake (no `cache: true`) still ran:
+  // the row is the only place a live run says so (`vx last` did).
+  if (o.flaky === undefined)
+    return (o.attempts ?? 1) > 1 ? ` ${paint('muted', `${o.attempts} attempts`, colors)}` : ''
   const said: string[] = []
   if (o.status === 'failed' && o.flaky.passes > 0)
     said.push(`passed ${o.flaky.passes}\u00d7 before`)
@@ -784,7 +810,6 @@ export function formatTaskSkippedLine(
   const suffix = why === '' ? '' : ` ${paint('muted', `• ${why}`, colors)}`
   return (
     formatTaskRow(
-      paint('warn', '\u2298', colors),
       null,
       'skipped',
       'warn',
@@ -811,29 +836,9 @@ export function formatTaskAbortedLine(
   const id = paintTaskId(node, colors)
   const bl: RowCells = blocks === undefined ? {} : { blocks: String(blocks) }
   if (neverStarted(o)) {
-    return formatTaskRow(
-      paint('muted', '\u25cc', colors),
-      null,
-      'not run',
-      '',
-      '',
-      '',
-      id,
-      colors,
-      bl,
-    )
+    return formatTaskRow(null, 'not run', '', '', '', id, colors, bl)
   }
-  return formatTaskRow(
-    paint('aborted', '\u2717', colors),
-    o.durationMs,
-    'aborted',
-    'aborted',
-    '',
-    '',
-    id,
-    colors,
-    ranCells(o, blocks),
-  )
+  return formatTaskRow(o.durationMs, 'aborted', 'aborted', '', '', id, colors, ranCells(o, blocks))
 }
 
 /**
@@ -889,7 +894,7 @@ function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[]
           ...(fix.inputs !== undefined
             ? [
                 dim(
-                  `and, if the output depends on them, inputs.files: [${fix.inputs.map((p) => `'${printable(p)}'`).join(', ')}]`,
+                  `and, if the output depends on them, inputs.files: [${fix.inputs.map(jsString).join(', ')}]`,
                 ),
               ]
             : []),
@@ -1062,6 +1067,9 @@ function formatStatusTag(o: TaskOutcome, colors: ColorSupport): string {
   }
 }
 
+/** A fix path as the single-quoted JS literal the config line pastes. */
+const jsString = (p: string): string => `'${printable(p.replace(/[\\']/g, '\\$&'))}'`
+
 /**
  * The fix as the config line it is: `exec.sandbox.allow: { read: ['a'] }`,
  * or undefined when every denial was a withheld credential path.
@@ -1070,7 +1078,7 @@ function sandboxFixLine(f: NonNullable<TaskOutcome['sandboxFix']>): string | und
   const fix = Object.entries(f).filter(([k]) => k !== 'withheld' && k !== 'inputs')
   if (fix.length === 0) return undefined
   const parts = fix.map(
-    ([k, list]: [string, string[]]) => `${k}: [${list.map((p) => `'${printable(p)}'`).join(', ')}]`,
+    ([k, list]: [string, string[]]) => `${k}: [${list.map(jsString).join(', ')}]`,
   )
   return `exec.sandbox.allow: { ${parts.join(', ')} }`
 }

package/src/report/index.ts

@@ -33,6 +33,7 @@ export {
 export {
   formatPersistentList,
   formatRecordedRow,
+  formatSize,
   planList,
   type PlannedRow,
   taskList,
@@ -40,4 +41,4 @@ export {
 export { createForecast } from './forecast.js'
 export { plainOutput } from './plain-output.js'
 export type { LiveUsage } from './status-line.js'
-export { formatOutcomeTable, formatRunSummary } from './summary.js'
+export { formatOutcomeTable, formatRunSummary, neverStarted } from './summary.js'