@vzn/vx 0.0.645 → 0.0.648

package/src/report/framed-output.ts

@@ -32,21 +32,35 @@ import {
   identityColor,
   maskedCommand,
   paint,
+  printable,
+  ruleWidth,
+  ui,
   type ColorSupport,
 } from '../util/index.js'
 import { neverStarted } from './summary.js'
-import { outcomeLabel, ranNoCache, skippedReason } from './events.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.
-// Section rules + the summary rule share one frame width.
-const FRAME_WIDTH = 60
 
 const SUCCESS = '#22c55e' // green-500 — success / fresh
 const WARN = '#eab308' // yellow-500 — skipped
@@ -98,8 +112,11 @@ export function formatTaskBlock(
 
   const idPainted = paintTaskId(node, colors, { bold: true })
   const corner = (s: string) => paint('', s, colors, { dim: true })
-  const header = formatBlockHeader(outcome, colors)
-  const lines: string[] = [`${corner('┌─')} ${idPainted} ${corner('>')} ${header}`]
+  // 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 lines: string[] = [`${corner('┌─')} ${mark}${idPainted} ${corner('>')} ${header}`]
 
   // The command section shows what actually ran — executed tasks
   // (success and failed). Cache hits normally skip it (the stored
@@ -124,10 +141,19 @@ export function formatTaskBlock(
 
   lines.push(...violationSection(outcome, colors))
 
-  lines.push(`${corner('└─')} ${idPainted} ${corner('──')}${formatBlockFooter(outcome, colors)}`)
+  lines.push(
+    `${corner('└─')} ${mark}${idPainted}${whereNote(outcome, colors)} ${corner('──')}${running ? runningFooter(outcome, colors) : formatBlockFooter(outcome, colors)}`,
+  )
   return lines.join('\n') + '\n'
 }
 
+/** 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,
+  })
+}
+
 /**
  * One `├─ <LABEL>` section of captured output, with the head-dropped notice
  * when the capture was bounded. Shared by the task frame and the persistent
@@ -144,9 +170,10 @@ function pushStreamSection(
   if (text.trim().length === 0) return
   lines.push(sectionLine(title, color, colors), '')
   if (lost > 0) {
-    lines.push(paint('', `… ${lost} earlier characters dropped`, colors, { dim: true }))
+    lines.push(droppedNote(lost, colors))
   }
   pushBodyLines(lines, text)
+  if (leavesStyle(text)) lines.push(`${lines.pop()}${RESET}`)
   lines.push('')
 }
 
@@ -168,7 +195,7 @@ function pushOutputSection(
   if (output.every((c) => c.text.trim().length === 0)) return
   lines.push(sectionLine('OUTPUT', '', colors), '')
   if (lost > 0) {
-    lines.push(paint('', `… ${lost} earlier characters dropped`, colors, { dim: true }))
+    lines.push(droppedNote(lost, colors))
   }
   const body: Array<{ text: string; err: boolean }> = []
   let open: { parts: string[]; err: boolean } | null = null
@@ -191,6 +218,8 @@ function pushOutputSection(
     if (!l.err || !colors.enabled) lines.push(text)
     else lines.push(l.text.includes('\x1b') ? 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}`)
   lines.push('')
 }
 
@@ -204,8 +233,8 @@ function pushOutputSection(
 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 })
-  const width = Math.min(FRAME_WIDTH, colors.columns ?? FRAME_WIDTH)
-  const rule = corner('─'.repeat(Math.max(1, width - 4 - title.length)))
+  // 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 +289,18 @@ function paintTaskId(node: TaskNode, colors: ColorSupport, opts: { bold?: boolea
 // the two axes out, 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"
+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'
 
 /** Right-align the duration in a TIME_COL cell (pad on the left). */
 function timeCell(ms: number | null, colors: ColorSupport): string {
-  const raw = ms === null ? '' : formatElapsed(ms)
+  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 })
 }
 
@@ -355,11 +389,32 @@ 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,
 ): 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)
-  return ` ${glyph} ${timeCell(ms, colors)} ${st} ${ca} ${paintedId}`
+  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}`
+}
+
+/**
+ * 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.
+ */
+export function formatListHeader(
+  worker: boolean,
+  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 })
 }
 
 /** Compact one-liner for a cache hit with nothing to replay. */
@@ -367,8 +422,24 @@ export function formatTaskHitLine(
   node: TaskNode,
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
+  onPath = false,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath)
+}
+
+/**
+ * The `--output-logs hash-only` line: outcome word, task id, cache key —
+ * absent for a task that never computed one (skipped, uncacheable). The
+ * word in its outcome's colour, the key dim.
+ */
+export function formatTaskHashLine(
+  node: TaskNode,
+  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 })}`
+  return `${paint(color, outcomeWord(o), colors)} ${paintTaskId(node, colors)}${key}`
 }
 
 /** Compact one-liner for an executed task in broad mode. */
@@ -376,8 +447,9 @@ export function formatTaskExecutedLine(
   node: TaskNode,
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
+  onPath = false,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath)
 }
 
 /** Shared: render any outcome on the grid. */
@@ -386,6 +458,7 @@ function formatOutcomeRow(
   paintedId: string,
   ms: number | null,
   colors: ColorSupport,
+  onPath: boolean,
 ): string {
   const st = statusOf(o)
   const ca = cacheOf(o)
@@ -399,10 +472,31 @@ function formatOutcomeRow(
       ca.color,
       paintedId,
       colors,
-    ) + flakyNote(o, colors)
+    ) +
+    (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)}`
+}
+
+/** 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 {
+  return o.where === undefined ? '' : placeNote(o.where, colors)
+}
+
+/**
+ * ` · <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)}`
+}
+
 /**
  * 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
@@ -429,9 +523,9 @@ export function flakyNote(o: TaskOutcome, colors: ColorSupport = NO_COLOR): stri
 export function formatTaskSkippedLine(
   node: TaskNode,
   colors: ColorSupport = NO_COLOR,
-  blockedBy?: string,
+  skip?: Parameters<typeof skippedReason>[0],
 ): string {
-  const why = skippedReason(blockedBy)
+  const why = skippedReason(skip)
   const suffix = why === '' ? '' : ` ${paint('', `• ${why}`, colors, { dim: true })}`
   return (
     formatTaskRow(
@@ -496,7 +590,7 @@ export function formatFrameOpen(
 ): string {
   const corner = (t: string) => paint('', t, colors, { dim: true })
   const cmd = shownCommand(node, forwardArgs)
-  const mark = isPersistentNode(node) ? `${paint(ACCENT, '▸', colors)} ` : ''
+  const mark = persistentMark(node, colors)
   return `${corner('┌─')} ${mark}${paintTaskId(node, colors, { bold: true })} ${corner('>')} $ ${cmd}`
 }
 
@@ -505,8 +599,8 @@ export function formatFrameOpen(
  * sees them in context with the failing task, not as loose status output
  * above the box. Shared by BOTH renderers: the focused/live frame used to
  * omit it, so a single-task run — exactly how someone debugging one task
- * invokes vx — showed a failure with no violations at all (owner,
- * 2026-09-05).
+ * invokes vx — showed a failure with no violations at all
+ * (2026-09-05).
  */
 function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[] {
   const vlines = outcome.sandboxViolationLines
@@ -516,11 +610,13 @@ function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[]
   // VERBATIM: a violation is evidence, and evidence that has been rewritten
   // for display is not the thing the sandbox reported. The outcome keeps
   // every record for telemetry.
-  const body = [...new Set(vlines)]
+  // Verbatim but for control bytes: a denied path is anyone's bytes, and
+  // one named `ESC ]0;…` retitled the terminal (the `\xNN` is still exact).
+  const body = [...new Set(vlines)].map(printable)
   // Red, not amber: a violation fails the task, so it reads as a failure.
   // vx's note, after the evidence: the grants that would have allowed it.
   // A read the output depends on is a key input too; the sandbox never
-  // adds one (owner, 2026-10-09), so the note names the reads no input
+  // adds one (2026-10-09), so the note names the reads no input
   // glob matches and the user decides.
   const fix = outcome.sandboxFix
   const line = fix === undefined ? undefined : sandboxFixLine(fix)
@@ -533,12 +629,16 @@ function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[]
           ...(fix.inputs !== undefined
             ? [
                 dim(
-                  `and, if the output depends on them, inputs.files: [${fix.inputs.map((p) => `'${p}'`).join(', ')}]`,
+                  `and, if the output depends on them, inputs.files: [${fix.inputs.map((p) => `'${printable(p)}'`).join(', ')}]`,
                 ),
               ]
             : []),
           ...(fix.withheld !== undefined
-            ? [dim(`credential path, grant it only on purpose: ${fix.withheld.join(', ')}`)]
+            ? [
+                dim(
+                  `credential path, grant it only on purpose: ${fix.withheld.map(printable).join(', ')}`,
+                ),
+              ]
             : []),
           '',
         ]
@@ -559,16 +659,15 @@ export function formatFrameClose(
   colors: ColorSupport = NO_COLOR,
 ): string {
   const corner = (t: string) => paint('', t, colors, { dim: true })
-  const persistent = isPersistentNode(node)
-  const mark = persistent ? `${paint(ACCENT, '▸', 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
   // both ends of the frame as a long-lived task.
   const tail =
-    persistent && outcome.status === 'success'
-      ? ` ${paint('', `(${formatElapsed(outcome.durationMs)})`, colors, { dim: true })} ${paint(ACCENT, 'running', colors)}`
+    mark !== '' && outcome.status === 'success' && outcome.serverExit === undefined
+      ? runningFooter(outcome, colors)
       : formatBlockFooter(outcome, colors)
-  const close = `${corner('└─')} ${mark}${paintTaskId(node, colors, { bold: true })} ${corner('──')}${tail}`
+  const close = `${corner('└─')} ${mark}${paintTaskId(node, colors, { bold: true })}${whereNote(outcome, colors)} ${corner('──')}${tail}`
   const violations = violationSection(outcome, colors)
   return violations.length === 0 ? close : `${violations.join('\n')}\n${close}`
 }
@@ -582,8 +681,12 @@ function shownCommand(node: TaskNode, forwardArgs: readonly string[]): string {
   )
 }
 
-function isPersistentNode(node: TaskNode): boolean {
-  return node.config.exec?.persistent !== undefined
+function persistentMark(node: TaskNode, colors: ColorSupport): string {
+  return node.config.exec?.persistent !== undefined ? `${paint(ACCENT, '▸', colors)} ` : ''
+}
+
+function runningFooter(o: TaskOutcome, colors: ColorSupport): string {
+  return ` ${paint('', `(${formatElapsed(o.durationMs)})`, colors, { dim: true })} ${paint(ACCENT, 'running', colors)}`
 }
 
 /**
@@ -625,10 +728,37 @@ export function formatKeptLines(node: TaskNode, text: string, colors: ColorSuppo
   const prefix = `${paintTaskId(node, colors)} ${paint('', '│', colors, { dim: true })} `
   return text
     .split('\n')
-    .map((line) => `${prefix}${line}\n`)
+    .map((line) => {
+      const shown = lastRedraw(line)
+      return `${prefix}${shown}${leavesStyle(shown) ? RESET : ''}\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
@@ -662,6 +792,8 @@ function formatBlockHeader(o: TaskOutcome, colors: ColorSupport): string {
       return paint(ERROR, word, colors, { bold: true })
     case 'skipped':
       return paint(WARN, word, colors)
+    case 'aborted':
+      return paint(ABORTED, word, colors)
     default:
       return dim(word)
   }
@@ -687,12 +819,10 @@ function formatStatusTag(o: TaskOutcome, colors: ColorSupport): string {
       return paint(ERROR, word, colors, { bold: true })
     case 'skipped':
       return paint(WARN, word, colors)
-    case 'cache-hit':
-    case 'cache-hit-remote':
-    case 'success':
-      return paint('', word, colors, { dim: true })
+    case 'aborted':
+      return paint(ABORTED, word, colors)
     default:
-      return o.status
+      return paint('', word, colors, { dim: true })
   }
 }
 
@@ -700,14 +830,11 @@ function formatStatusTag(o: TaskOutcome, colors: ColorSupport): string {
  * The fix as the config line it is: `exec.sandbox.allow: { read: ['a'] }`,
  * or undefined when every denial was a withheld credential path.
  */
-function sandboxFixLine({
-  withheld: _,
-  inputs: __,
-  ...fix
-}: NonNullable<TaskOutcome['sandboxFix']>): string | undefined {
-  if (Object.keys(fix).length === 0) return undefined
-  const parts = Object.entries(fix).map(
-    ([k, list]: [string, string[]]) => `${k}: [${list.map((p) => `'${p}'`).join(', ')}]`,
+function sandboxFixLine(f: NonNullable<TaskOutcome['sandboxFix']>): string | undefined {
+  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(', ')}]`,
   )
   return `exec.sandbox.allow: { ${parts.join(', ')} }`
 }

package/src/report/index.ts

@@ -15,6 +15,7 @@ export {
   type RunEvent,
   type RunEventSubscriber,
   type RunStartInfo,
+  skippedReason,
   type TaskView,
   terminalSubscriber,
   toWireEvent,