@vzn/vx 0.0.651 → 0.0.653

package/src/report/logger.ts

@@ -12,7 +12,6 @@ import {
   executedCells,
   formatTaskExecutedLine,
   flakyNote,
-  pathNote,
   formatTaskHashLine,
   formatTaskHitLine,
   formatTaskSkippedLine,
@@ -32,12 +31,14 @@ import {
   type RunContext,
   type TaskBucket,
 } from './summary.js'
-import { isGroupTask } from '../graph/index.js'
+import { isGroupTask, isKeyFailed } from '../graph/index.js'
 import {
   appendTail,
   createTail,
   formatElapsed,
+  maskStreams,
   resetTail,
+  secretMask,
   tailText,
   type Tail,
   envFlagOn,
@@ -58,7 +59,7 @@ import {
   type StatusStream,
 } from '../ui/index.js'
 import { isCacheHit } from '../graph/index.js'
-import { failedLabel, outcomeWord, ranNoCache } from './events.js'
+import { outcomeLabel, outcomeWord, ranNoCache } from './events.js'
 import type { BlockedTask, Forecast } from './forecast.js'
 
 export interface Logger {
@@ -204,10 +205,17 @@ function ghaProperty(value: string): string {
  * one could simply be printed by the task — so it is a per-run UUID.
  */
 function ghaFence(body: string, token: string): string {
-  return `::stop-commands::${token}\n${body}::${token}::\n`
+  const [open, close] = ghaFenceEnds(token)
+  return `${open}${body}${close}`
 }
 
-const cacheWordOf = (o: TaskOutcome): 'miss' | 'no-cache' => (ranNoCache(o) ? 'no-cache' : 'miss')
+/** The lines `ghaFence` puts before and after the text. */
+function ghaFenceEnds(token: string): [open: string, close: string] {
+  return [`::stop-commands::${token}\n`, `::${token}::\n`]
+}
+
+const cacheWordOf = (o: TaskOutcome): 'miss' | 'no-cache' | '' =>
+  o.restoreFailed === true || isKeyFailed(o) ? '' : ranNoCache(o) ? 'no-cache' : 'miss'
 
 export function resolveOutputView(
   options: {
@@ -239,6 +247,9 @@ const NOTIFY_AFTER_MS = 10_000
 // A step of vx's own quicker than this shows nowhere (2026-10-15).
 const STEP_SHOWN_MS = 150
 
+/** A frame this long is written in pieces, never copied into one string. */
+const PIECEWISE_CHARS = 1024 * 1024
+
 export function defaultLogger(
   colors: ColorSupport = detectColors(),
   view: OutputView = { mode: 'full' },
@@ -373,15 +384,19 @@ export function defaultLogger(
   let slots: (WorkerSlot | null)[] = []
   const slotQueue: WorkerSlot[] = []
   let succeeded = 0
-  // Executed with no `cache` block: never a miss, counted apart.
+  // Executed without `cache: true`: never a miss, counted apart.
   let noCache = 0
   let upToDate = 0
   let restoredLocal = 0
   let restoredRemote = 0
+  // Hits whose restore failed: failed, and in no cache count.
+  let restoreFailed = 0
+  // A task with no key asked no cache: not a miss.
+  let keyFailed = 0
   let saved = 0
   let notSaved = 0
   let skippedCount = 0
-  // Each finished task's cache bucket by its key: its remote traffic moves it.
+  // Each finished task's cache bucket by its key, with a remote: its traffic moves it.
   const buckets = new Map<string, TaskBucket>()
   // The graph is done and vx's own closing steps run: the region stays,
   // footer and step rows, until the footer replaces it (2026-10-15).
@@ -405,7 +420,7 @@ export function defaultLogger(
   // The pinned zone above the worker rows: persistent tasks pin at
   // ready (their outcome lands while the child keeps running) and live
   // until runEnd kills the region. A failure is not pinned: it is a
-  // permanent ◼ row the moment it happens, and its full frame is
+  // permanent failed row the moment it happens, and its full frame is
   // deferred to runEnd (owner: '✗ line, continue, all full frames at
   // the end'). 'full'/CI keeps frames inline.
   const deferredFailures: string[] = []
@@ -566,8 +581,9 @@ export function defaultLogger(
               restoredRemote,
               saved,
               notSaved,
-              miss: succeeded + failed - noCache,
+              miss: succeeded + failed - noCache - restoreFailed - keyFailed,
               noCache,
+              ...(restoreFailed > 0 ? { restoreFailed } : {}),
               left: total - done - stopped - notRun,
               ...(running > 0 ? { running } : {}),
               ...(scheduled > 0 ? { scheduled } : {}),
@@ -676,8 +692,11 @@ export function defaultLogger(
     if (chunk.length > 0) endsBlank = chunk.endsWith('\n\n')
     if (!logOpened && chunk.length > 0) {
       logOpened = true
-      writer.write(`\n${chunk}`)
-      return
+      if (chunk.length < PIECEWISE_CHARS) {
+        writer.write(`\n${chunk}`)
+        return
+      }
+      writer.write('\n')
     }
     writer.write(chunk)
   }
@@ -706,8 +725,7 @@ export function defaultLogger(
     if (panelOpen === 'Warnings') closePanel()
     inPanel = true
     if (panelOpen !== 'Tasks') {
-      emitLine(ui.panelTop('Tasks', colors))
-      emitLine(formatListHeader(colors))
+      emitLine(ui.panelTop('Tasks', colors, undefined, undefined, formatListHeader(colors)))
       panelOpen = 'Tasks'
     }
     emitLine(line)
@@ -715,11 +733,20 @@ export function defaultLogger(
   }
   // formatTaskBlock returns '' for group tasks (no exec) — skip the
   // write so a stray newline doesn't sneak into the output.
-  const emitBlock = (block: string): void => {
+  // `head` and `tail` wrap the block. A big one is written in pieces:
+  // joined into one string, a frame of a 100 MB log was copied whole again
+  // (200 MB, two bytes a character once the frame's corners are in it).
+  const emitBlock = (block: string, head = '', tail = ''): void => {
     if (block.length === 0) return
     endStreamLine()
     const lead = lineEmitted || streamedSinceBlock ? '\n' : ''
-    taskWrite(`${lead}${block}\n`)
+    if (block.length < PIECEWISE_CHARS) taskWrite(`${lead}${head}${block}${tail}\n`)
+    else {
+      logWrite(lead + head)
+      logWrite(block)
+      logWrite(`${tail}\n`)
+      endsBlank = (tail || block).endsWith('\n')
+    }
     lineEmitted = false
     streamedSinceBlock = false
   }
@@ -760,10 +787,12 @@ export function defaultLogger(
   const failureRow = (node: TaskNode, outcome: TaskOutcome): string =>
     formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(outcome), {
       ...executedCells(outcome, blocksOf(node.id)),
-      usual: usualCell(outcome.durationMs, usualMsOf(node.id), colors),
-    }) +
-    (onPath.has(node.id) ? pathNote(colors) : '') +
-    flakyNote(outcome, colors)
+      // A failed restore ran no command: nothing to compare.
+      ...(outcome.restoreFailed === true
+        ? {}
+        : { usual: usualCell(outcome.durationMs, usualMsOf(node.id), colors) }),
+      ...(onPath.has(node.id) ? { critical: true } : {}),
+    }) + flakyNote(outcome, colors)
 
   return {
     showsSteps: writer.enabled,
@@ -780,8 +809,13 @@ export function defaultLogger(
       // summary row or "exited with code" can follow its partial line.
       endStreamLine()
       closePanel()
-      if (line === '' && endsBlank) return
-      endsBlank = line === ''
+      // A block's own trailing blank stands for the first blank status line; a second one is meant
+      // (two before the Summary).
+      if (line === '' && endsBlank) {
+        endsBlank = false
+        return
+      }
+      endsBlank = false
       writer.write(`${line}\n`)
     },
     warn(line) {
@@ -957,7 +991,7 @@ export function defaultLogger(
         }
       }
       // Failures end the log: every deferred frame replays here, right
-      // above the summary — the ◼ rows marked them in the stream,
+      // above the summary — the failed rows marked them in the stream,
       // the full diagnostics read last where eyes land.
       // Guarded for repeat runEnd calls.
       if (!flushedFailures && deferredFailures.length > 0) {
@@ -1008,12 +1042,23 @@ export function defaultLogger(
       const preReady = persistentTails.get(node.id)
       // In the order the task wrote it; a bounded tail kept its streams
       // apart, so its stdout reads first.
-      const output: OutputChunk[] = preReady
+      let output: OutputChunk[] = preReady
         ? [
             { text: tailText(preReady.out), err: false },
             { text: tailText(preReady.err), err: true },
           ]
         : takeChunks(node.id)
+      // The live mask lets a held piece go after a pause, so a value the
+      // task wrote in two pieces arrived as two clean chunks. The frame
+      // prints now with the whole text in hand: each stream is masked as
+      // a whole, as the stored log is. A hit's replay already was.
+      if (!isCacheHit(outcome.status) && output.some((c) => c.text.length > 0)) {
+        const mask = secretMask(
+          [process.env, node.config.exec?.env?.define],
+          node.config.exec?.env?.secret,
+        )
+        if (mask !== null) output = maskStreams(output, mask)
+      }
       const dropped =
         preReady && (preReady.out.dropped > 0 || preReady.err.dropped > 0)
           ? { droppedStdout: preReady.out.dropped, droppedStderr: preReady.err.dropped }
@@ -1041,9 +1086,13 @@ export function defaultLogger(
         // the terminal where a frame would have: a task that traps Ctrl-C
         // and exits 0 is aborted since item 962, and its frame was dropped
         // with the count. A task that never started opened no frame.
+        // A list view prints a failure's output; a killed task's partial
+        // output is what tells where a run hung, so it prints too.
         const framed =
           !neverStarted(outcome) &&
           (view.mode === 'full' ||
+            view.mode === 'broad' ||
+            view.mode === 'errors-only' ||
             (view.mode === 'focused' && isPrimary(node)) ||
             (framesTerminal && holdsTerminal(node)))
         if (framed && streamsLive(node)) {
@@ -1051,6 +1100,23 @@ export function defaultLogger(
           return
         }
         if (framed && output.some((c) => c.text.length > 0)) {
+          // A list view treats it as a failure: the row now, the frame
+          // with the deferred failures above the summary.
+          if (view.mode === 'broad' || view.mode === 'errors-only') {
+            emitRow(formatTaskAbortedLine(node, outcome, colors, blocksOf(node.id)))
+            deferredFailures.push(
+              formatTaskBlock(
+                node,
+                outcome,
+                { output, ...dropped },
+                colors,
+                true,
+                forwardArgs,
+                links,
+              ),
+            )
+            return
+          }
           emitBlock(
             fenced(
               formatTaskBlock(
@@ -1078,7 +1144,9 @@ export function defaultLogger(
         done++
         if (outcome.status === 'failed') {
           failed++
-          if (ranNoCache(outcome)) noCache++
+          if (outcome.restoreFailed === true) restoreFailed++
+          else if (isKeyFailed(outcome)) keyFailed++
+          else if (ranNoCache(outcome)) noCache++
         } else if (node.config.exec?.persistent !== undefined && outcome.status === 'success') {
           // A persistent task's outcome arrives at READY; the child
           // keeps running until the orchestrator SIGTERMs it at run
@@ -1101,7 +1169,9 @@ export function defaultLogger(
             if (qi >= 0) slotQueue.splice(qi, 1)
           }
         }
-        const bucket = cacheBucketOf(outcome)
+        // Only a remote's traffic moves a bucket: without one, an entry per
+        // task was held for the run and never read.
+        const bucket = runContext?.cache?.remote === true ? cacheBucketOf(outcome) : undefined
         if (bucket !== undefined) {
           const entry = { task: node.id, bucket }
           if (outcome.hash !== undefined) buckets.set(outcome.hash, entry)
@@ -1126,7 +1196,10 @@ export function defaultLogger(
             skippedCount++
             break
         }
-        if (outcome.status === 'success' || outcome.status === 'failed') {
+        if (
+          outcome.status === 'success' ||
+          (outcome.status === 'failed' && outcome.restoreFailed !== true)
+        ) {
           spreadMax = Math.max(spreadMax, outcome.durationMs)
           spreadMin = Math.min(spreadMin, outcome.durationMs)
           spreadSum += outcome.durationMs
@@ -1175,7 +1248,7 @@ export function defaultLogger(
           // their replay buffers are deliberately dropped; the counts
           // surface in the end-of-run summary.
           if (outcome.status === 'failed') {
-            // ◼ row now; the full frame replays at runEnd.
+            // failed row now; the full frame replays at runEnd.
             emitRow(failureRow(node, outcome))
             deferredFailures.push(
               formatTaskBlock(
@@ -1258,7 +1331,7 @@ export function defaultLogger(
             return
           }
           // Dependency-pulled nodes: silent on success; a skip gets its
-          // row, failures the ◼ row now and their frame replayed at runEnd.
+          // row, failures the failed row now and their frame replayed at runEnd.
           if (outcome.status === 'skipped') {
             emitRow(formatTaskSkippedLine(node, colors, outcome, blocksOf(node.id)))
           } else if (outcome.status === 'failed') {
@@ -1307,20 +1380,24 @@ export function defaultLogger(
             // The block is the task's own output — fenced, so a task that
             // prints `::endgroup::` can't close vx's group early and an
             // `::error` line in its output can't become a real annotation.
-            const body = ghaFence(block, ghaToken)
+            const [open, close] = ghaFenceEnds(ghaToken)
             // Failed tasks stay pre-expanded in the Actions viewer:
             // an ::error annotation instead of a collapsed group.
             if (outcome.status === 'failed') {
               // The message is ours (a literal, an integer and a signal
               // name); only the title carries user input.
               emitBlock(
-                `::error title=${ghaProperty(node.id)}::${failedLabel(outcome.exitCode, outcome.timedOut, outcome.sandboxViolations, outcome.notReady, outcome.inputMoved)}\n${body}`,
+                block,
+                `::error title=${ghaProperty(node.id)}::${outcomeLabel(outcome)}\n${open}`,
+                close,
               )
             } else {
               emitBlock(
+                block,
                 `::group::${ghaData(
                   `${node.id} (${outcomeWord(outcome)} ${formatElapsed(outcome.durationMs)})`,
-                )}\n${body}::endgroup::\n`,
+                )}\n${open}`,
+                `${close}::endgroup::\n`,
               )
             }
             return

package/src/report/plain-output.ts

@@ -1,12 +1,16 @@
 import type { TaskNode } from '../graph/index.js'
+import { stripEscapes } from '../util/index.js'
 import type { Logger } from './logger.js'
 
-// A prefix that may yet complete as a CSI, OSC or charset sequence
-// (`tput sgr0` writes `\x1b(B`). An escape cut at a chunk's end is held for
-// the next chunk: stripped alone, its remainder (`1m`, `B`) reached the log
-// as text.
+// A prefix that may yet complete as a CSI, string (OSC, DCS, SOS, PM, APC)
+// or charset sequence (`tput sgr0` writes `\x1b(B`). An escape cut at a
+// chunk's end is held for the next chunk: stripped alone, its remainder
+// (`1m`, `B`) reached the log as text. A string escape ends at its line
+// (stripEscapes), so it is held only within one, and only up to HOLD_MAX:
+// an unbounded hold joined every later chunk and lost them at the task's end.
 // eslint-disable-next-line no-control-regex -- ESC is the point
-const PARTIAL_ESCAPE = /^\x1b(?:\[[0-?]*[ -/]*|\][^\x07\x1b]*\x1b?|[ -/]+)?$/
+const PARTIAL_ESCAPE = /^\x1b(?:\[[0-?]*[ -/]*|[\]P_^X][^\x07\x1b\n]*\x1b?|[ -/]+)?$/
+const HOLD_MAX = 4096
 
 /**
  * `sink` with terminal escapes stripped from task output. Tasks run with
@@ -21,17 +25,17 @@ export function plainOutput(sink: Logger): Logger {
     if (prior !== undefined) held.delete(key)
     const esc = text.lastIndexOf('\x1b')
     if (esc === -1) return text
-    if (PARTIAL_ESCAPE.test(text.slice(esc))) {
+    if (text.length - esc <= HOLD_MAX && PARTIAL_ESCAPE.test(text.slice(esc))) {
       held.set(key, text.slice(esc))
-      return Bun.stripANSI(text.slice(0, esc))
+      return stripEscapes(text.slice(0, esc))
     }
-    return Bun.stripANSI(text)
+    return stripEscapes(text)
   }
   const flush = (node: TaskNode, key: string, write: (n: TaskNode, c: string) => void): void => {
     const rest = held.get(key)
     if (rest === undefined) return
     held.delete(key)
-    const text = Bun.stripANSI(rest)
+    const text = stripEscapes(rest)
     if (text !== '') write(node, text)
   }
   // Delegated one by one, never spread: an embedder's logger may be a class
@@ -57,6 +61,8 @@ export function plainOutput(sink: Logger): Logger {
       if (text !== '' || chunk === '') sink.taskStderr(node, text)
     },
     taskComplete(node, outcome) {
+      // Nearly every task ends with no escape held: its keys go unbuilt.
+      if (held.size === 0) return sink.taskComplete(node, outcome)
       flush(node, `${node.id}\0out`, (n, c) => sink.taskStdout(n, c))
       flush(node, `${node.id}\0err`, (n, c) => sink.taskStderr(n, c))
       sink.taskComplete(node, outcome)

package/src/report/status-line.ts

@@ -1,13 +1,11 @@
 // The live region's panels: Warnings, Running and the live Summary,
 // redrawn in place under the log by the ui module's writer.
 
-import { paint, panelTop, type ColorSupport } from '../ui/index.js'
+import { divider, paint, type ColorSupport } from '../ui/index.js'
 import {
   formatExpected,
-  formatRunningHeader,
   formatTaskRow,
   paintIdParts,
-  pathNote,
   type RowCells,
   unknownUsual,
 } from './framed-output.js'
@@ -93,18 +91,18 @@ function paintPinnedId(id: string, colors: ColorSupport): string {
 /**
  * Permanent one-liner logged the moment a task fails (owner design:
  * "log the failure and continue, full frames at the end"). On the grid:
- * red ◼ glyph + exec time + `failed` + `miss` + id. The exit code and
+ * `failed` in red + exec time + `miss` + id. The exit code and
  * output live in the framed block that replays at runEnd, not the line.
+ * A hit whose restore failed has `''`, shown `—`: neither a miss nor a hit.
  */
 export function formatFailureLine(
   id: string,
   durationMs: number | null,
   colors: ColorSupport = NO_COLOR,
-  cacheWord: 'miss' | 'no-cache' = 'miss',
+  cacheWord: 'miss' | 'no-cache' | '' = 'miss',
   cells: RowCells = {},
 ): string {
   return formatTaskRow(
-    paint('error', '\u25fc\uFE0E', colors),
     durationMs,
     'failed',
     'error',
@@ -131,7 +129,6 @@ export function formatStepLine(
   colors: ColorSupport = NO_COLOR,
 ): string {
   return formatTaskRow(
-    ok ? paint('ok', '\u23fa\uFE0E', colors) : paint('error', '\u25fc\uFE0E', colors),
     durationMs,
     ok ? 'success' : 'failed',
     ok ? 'ok' : 'error',
@@ -144,9 +141,6 @@ export function formatStepLine(
 }
 
 /** `rows` in a panel titled `title`, counted. */
-function panel(title: string, count: string, rows: readonly string[], c: ColorSupport): string[] {
-  return [panelTop(title, c, count), ...rows]
-}
 
 /**
  * Worker region: pinned ready persistent tasks, one row per worker
@@ -171,26 +165,18 @@ export function formatStatusRegion(
   }
   // The Running panel's rows; its box and header go round them below.
   const lines: string[] = []
-  // Persistent (dev-server) rows: ▸ glyph, no elapsed, `running`, no
+  // Persistent (dev-server) rows: `running`, no elapsed, no
   // cache state (it's still alive).
   for (const id of s.pinnedPersistent) {
     lines.push(
-      formatTaskRow(
-        paint('info', '▸', colors),
-        null,
-        'running',
-        'info',
-        '',
-        '',
-        paintPinnedId(id, colors),
-        colors,
-        { worker: 'local' },
-      ),
+      formatTaskRow(null, 'running', 'warn', '', '', paintPinnedId(id, colors), colors, {
+        worker: 'local',
+      }),
     )
   }
 
-  // Running rows: NO glyph — the live elapsed time leads (no spinner;
-  // the ticking time IS the motion), then `running`, the usual duration,
+  // Running rows: `running` in yellow, then the live elapsed time (no
+  // spinner; the ticking time IS the motion), the usual duration,
   // how many tasks wait on it, and the full id (never truncated — name is
   // the last column). The rows no task runs in hold the tasks planned
   // next, each nested under what it waits on. No blank rows pad the list
@@ -218,7 +204,6 @@ export function formatStatusRegion(
     if (s.stopping === true) {
       lines.push(
         formatTaskRow(
-          ' ',
           Math.max(0, s.nowMs - slot.startedMs),
           'aborting',
           'warn',
@@ -233,28 +218,26 @@ export function formatStatusRegion(
     }
     const at = s.where?.(slot.id)
     const use = s.usage?.(slot.id)
-    lines.push(
-      formatTaskRow(
-        ' ',
-        Math.max(0, s.nowMs - slot.startedMs),
-        'running',
-        'info',
-        slot.cache ?? 'miss',
-        '',
-        paintPinnedId(slot.id, colors),
-        colors,
-        {
-          usual: usualOf(slot.id),
-          ...(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) : ''),
+    const row = formatTaskRow(
+      Math.max(0, s.nowMs - slot.startedMs),
+      'running',
+      'warn',
+      slot.cache ?? 'miss',
+      '',
+      paintPinnedId(slot.id, colors),
+      colors,
+      {
+        usual: usualOf(slot.id),
+        ...(use !== undefined ? { cpu: use.cores, memBytes: use.rssBytes } : {}),
+        blocks: String(s.blockedBy?.get(slot.id) ?? 0),
+        worker: at ?? 'local',
+        ...(s.critical === slot.id ? { critical: true } : {}),
+      },
     )
+    lines.push(row)
     for (const b of nested.get(slot.id) ?? []) {
       lines.push(
         formatTaskRow(
-          ' ',
           null,
           'blocked',
           '',
@@ -270,10 +253,9 @@ export function formatStatusRegion(
   for (const step of s.steps ?? []) {
     lines.push(
       formatTaskRow(
-        ' ',
         Math.max(0, s.nowMs - step.startedMs),
         'running',
-        'info',
+        'warn',
         INTERNAL,
         '',
         paintPinnedId(step.id, colors),
@@ -285,16 +267,7 @@ export function formatStatusRegion(
   // Panels top to bottom: what runs now, then the live Summary, the same panel the final printout is, so the region
   // BECOMES the summary when the run ends.
   const out: string[] = []
-  if (lines.length > 0)
-    out.push(
-      '',
-      ...panel(
-        'Running',
-        String(s.pinnedPersistent.length + running.length + (s.steps?.length ?? 0)),
-        [formatRunningHeader(colors), ...lines],
-        colors,
-      ),
-    )
+  if (lines.length > 0) out.push(divider(colors), '', ...lines)
   out.push(...s.summaryLines)
   return out
 }