@vzn/vx 0.0.18 → 0.0.22

package/src/orchestrator/logger.ts

@@ -1,6 +1,7 @@
 import type { TaskNode, TaskOutcome } from '../graph/index.js'
 import { detectColors, type ColorSupport } from './colors.js'
 import {
+  formatFailureRecap,
   formatFrameClose,
   formatFrameOpen,
   formatPersistentTailBlock,
@@ -8,7 +9,15 @@ import {
   formatTaskExecutedLine,
   formatTaskHitLine,
   formatTaskSkippedLine,
+  type RecapEntry,
 } from './framed-output.js'
+import {
+  appendRecapRing,
+  createRecapRing,
+  RECAP_TASKS,
+  recapTail,
+  type RecapRing,
+} from './failure-recap.js'
 import {
   createOutputWriter,
   formatFailureLine,
@@ -20,6 +29,7 @@ import { formatDuration, formatSummarySection, type RunContext } from './summary
 import { isGroupTask } from '../graph/index.js'
 import { appendTail, createTail, resetTail, tailText, type Tail } from '../util/index.js'
 import { isCacheHit } from './telemetry.js'
+import { failedLabel, outcomeWord } from './events.js'
 
 export interface Logger {
   /** Header / footer / status text. Written verbatim, one trailing \n added. */
@@ -52,6 +62,21 @@ export interface Logger {
   runEnd?(): void
 }
 
+/** The logger `run()` builds when none is passed, and the one that owns the recap. */
+export interface DefaultLogger extends Logger {
+  /**
+   * The run's last block: each failed task's last lines (item 706). Empty
+   * when nothing failed, and in the modes that promise no task output.
+   */
+  failureRecap(): string[]
+  /**
+   * Hand over any output still coalesced, and write straight through from
+   * now on. `runEnd` does it; the run's own `finally` does it again for a
+   * throw that never reached `runEnd`.
+   */
+  settle(): void
+}
+
 /**
  * The default logger's per-task output policy. Resolved once per run
  * from (in priority order) the explicit `--output-logs` override, a
@@ -124,19 +149,8 @@ function ghaFence(body: string, token: string): string {
   return `::stop-commands::${token}\n${body}::${token}::\n`
 }
 
-/** The unified outcome vocabulary word for a non-failed outcome. */
-function outcomeWord(o: TaskOutcome): string {
-  switch (o.status) {
-    case 'success':
-      return 'success'
-    case 'cache-hit':
-      return o.restored === false ? 'up-to-date' : 'restored-local'
-    case 'cache-hit-remote':
-      return o.restored === false ? 'up-to-date' : 'restored-remote'
-    default:
-      return o.status
-  }
-}
+const cacheWordOf = (n: TaskNode): 'miss' | 'no-cache' =>
+  n.config.cache === undefined ? 'no-cache' : 'miss'
 
 export function resolveOutputView(
   options: {
@@ -162,8 +176,8 @@ export function defaultLogger(
   colors: ColorSupport = detectColors(),
   view: OutputView = { mode: 'full' },
   out: StatusStream = process.stdout,
-  opts: { forceFloorMs?: number } = {},
-): Logger {
+  opts: { forceFloorMs?: number; coalesce?: boolean } = {},
+): DefaultLogger {
   // Per-task buffers, split by stream. Splitting lets the framed-output
   // renderer put stdout under `├─ stdout` and stderr under `├─ stderr`.
   // The price: chunks that interleaved at runtime get re-ordered (all
@@ -182,8 +196,6 @@ export function defaultLogger(
   // a one-liner or streamed output since the last block does.
   let lineEmitted = false
   let streamedSinceBlock = false
-  // Ids whose output went straight to the terminal (focused mode).
-  const streamed = new Set<string>()
   // True while the live stream sits mid-line (chunk without trailing
   // newline) — the frame close must not glue onto partial output.
   let streamMidLine = false
@@ -227,6 +239,7 @@ export function defaultLogger(
   const writer = createOutputWriter(out, {
     enabled: view.ci !== true,
     ...(opts.forceFloorMs !== undefined ? { forceFloorMs: opts.forceFloorMs } : {}),
+    ...(opts.coalesce === true ? { coalesce: true } : {}),
   })
 
   // Status-display state, driven by the optional lifecycle hooks.
@@ -257,6 +270,8 @@ export function defaultLogger(
   let slots: (WorkerSlot | null)[] = []
   const slotQueue: WorkerSlot[] = []
   let succeeded = 0
+  // Executed with no `cache` block: never a miss, counted apart.
+  let noCache = 0
   let upToDate = 0
   let restoredLocal = 0
   let restoredRemote = 0
@@ -267,11 +282,12 @@ export function defaultLogger(
   let spreadMin = Infinity
   let spreadSum = 0
   let spreadCount = 0
-  // Pinned zones above the worker rows: failures accumulate as they
-  // happen; persistent tasks pin at ready (their outcome lands while
-  // the child keeps running). Both live until runEnd kills the region.
-  // Full failure frames, deferred to runEnd (owner: '✗ line, continue,
-  // all full frames at the end'). 'full'/CI keeps frames inline.
+  // 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
+  // deferred to runEnd (owner: '✗ line, continue, all full frames at
+  // the end'). 'full'/CI keeps frames inline.
   const deferredFailures: string[] = []
   const pinnedPersistent: string[] = []
   let flushedFailures = false
@@ -297,6 +313,13 @@ export function defaultLogger(
     { node: TaskNode; outcome?: TaskOutcome; out: Tail; err: Tail }
   >()
   let flushedPersistent = false
+  // The recap's material, decided at each failure so nothing is held for a
+  // task that passed. A buffered task's tail is read off the buffers the
+  // frame drains; a live-streamed one keeps no buffer, so a bounded ring
+  // follows it from its frame-open until its outcome.
+  const recapEntries: RecapEntry[] = []
+  const recapMore: string[] = []
+  const liveRings = new Map<string, RecapRing>()
 
   const refresh = (force: boolean): void => {
     if (statusDead) return
@@ -311,7 +334,8 @@ export function defaultLogger(
         upToDate,
         restoredLocal,
         restoredRemote,
-        miss: succeeded + failed,
+        miss: succeeded + failed - noCache,
+        noCache,
         left: total - done,
         spread:
           spreadCount > 0
@@ -381,6 +405,23 @@ export function defaultLogger(
     view.mode === 'focused' && isPrimary(node) && !isGroupTask(node) && requestedCount <= 1
 
   return {
+    settle() {
+      writer.settle()
+    },
+    failureRecap() {
+      if (recapEntries.length === 0) return []
+      // Fenced like a frame: a tail is the task's own text, and a line of it
+      // must not become a workflow command. Never inside a group, so it reads
+      // with every group collapsed.
+      const fence =
+        view.gha === true
+          ? (lines: string[]) =>
+              ghaFence(`${lines.join('\n')}\n`, ghaToken)
+                .slice(0, -1)
+                .split('\n')
+          : undefined
+      return formatFailureRecap(recapEntries, recapMore, colors, fence)
+    },
     status(line) {
       writer.write(`${line}\n`)
     },
@@ -413,6 +454,7 @@ export function defaultLogger(
         // Open the live frame: full task info even when the command
         // streams nothing (or the hit replays nothing).
         emitLine(formatFrameOpen(node, colors))
+        liveRings.set(node.id, createRecapRing())
         return
       }
       // Bound a persistent task's output from its FIRST chunk. Waiting for
@@ -461,21 +503,25 @@ export function defaultLogger(
         }
       }
       // Failures end the log: every deferred frame replays here, right
-      // above the summary — the ✗ one-liners marked them in the
-      // stream, the full diagnostics read last where eyes land.
+      // above the summary — the ◼ rows marked them in the stream,
+      // the full diagnostics read last where eyes land.
       // Guarded for repeat runEnd calls.
       if (!flushedFailures && deferredFailures.length > 0) {
         flushedFailures = true
         for (const block of deferredFailures) emitBlock(block)
       }
+      // The summary and the CLI's own lines follow on the stream directly:
+      // nothing may still be held, and nothing after this is.
+      writer.settle()
     },
     taskStdout(node, chunk) {
       if (discardsOutput) return
       if (streamsLive(node)) {
-        streamed.add(node.id)
         streamedSinceBlock = true
         if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
         writer.write(chunk)
+        const ring = liveRings.get(node.id)
+        if (ring !== undefined) appendRecapRing(ring, chunk)
         return
       }
       const tail = persistentTails.get(node.id)
@@ -488,10 +534,11 @@ export function defaultLogger(
     taskStderr(node, chunk) {
       if (discardsOutput) return
       if (streamsLive(node)) {
-        streamed.add(node.id)
         streamedSinceBlock = true
         if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
         writer.write(chunk)
+        const ring = liveRings.get(node.id)
+        if (ring !== undefined) appendRecapRing(ring, chunk)
         return
       }
       const tail = persistentTails.get(node.id)
@@ -516,6 +563,28 @@ export function defaultLogger(
       // The pre-ready window closed either way: a failed task is over, and
       // a ready one starts a fresh post-ready tail below.
       persistentTails.delete(node.id)
+      const liveRing = liveRings.get(node.id)
+      liveRings.delete(node.id)
+      if (outcome.status === 'failed' && !discardsOutput) {
+        if (recapEntries.length === RECAP_TASKS) recapMore.push(node.id)
+        else {
+          let ring = liveRing
+          if (ring === undefined) {
+            ring = createRecapRing()
+            appendRecapRing(ring, stdout)
+            if (stdout.length > 0 && stderr.length > 0 && !stdout.endsWith('\n')) {
+              appendRecapRing(ring, '\n')
+            }
+            appendRecapRing(ring, stderr)
+          }
+          recapEntries.push({
+            node,
+            outcome,
+            tail: recapTail(ring),
+            droppedChars: (preReady?.out.dropped ?? 0) + (preReady?.err.dropped ?? 0),
+          })
+        }
+      }
       // An aborted task (child killed by a shutdown signal) reverts
       // to pending: free its worker slot, but never count or render it
       // — the run is tearing down and it has no honest outcome.
@@ -527,6 +596,22 @@ export function defaultLogger(
           if (qi >= 0) slotQueue.splice(qi, 1)
         }
         refresh(true)
+        // What it printed while it stopped (a trap's cleanup) still reaches
+        // 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.
+        const framed = view.mode === 'full' || (view.mode === 'focused' && isPrimary(node))
+        if (framed && !isGroupTask(node)) {
+          if (streamsLive(node)) {
+            if (streamMidLine) {
+              writer.write('\n')
+              streamMidLine = false
+            }
+            emitFrameClose(formatFrameClose(node, outcome, colors))
+          } else if (stdout.length > 0 || stderr.length > 0) {
+            emitBlock(formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors, true))
+          }
+        }
         return
       }
       // Group tasks (no exec) do no work — no surface prints them.
@@ -534,6 +619,7 @@ export function defaultLogger(
         done++
         if (outcome.status === 'failed') {
           failed++
+          if (node.config.cache === undefined) 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
@@ -557,6 +643,7 @@ export function defaultLogger(
         switch (outcome.status) {
           case 'success':
             succeeded++
+            if (node.config.cache === undefined) noCache++
             break
           case 'cache-hit':
             if (outcome.restored === false) upToDate++
@@ -593,7 +680,7 @@ export function defaultLogger(
         }
         case 'errors-only':
           if (outcome.status !== 'failed') return
-          emitLine(formatFailureLine(node.id, outcome.durationMs, colors))
+          emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
           deferredFailures.push(
             formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
           )
@@ -604,8 +691,8 @@ export function defaultLogger(
           // their replay buffers are deliberately dropped; the counts
           // surface in the end-of-run summary.
           if (outcome.status === 'failed') {
-            // ✗ marker now; the full frame replays at runEnd.
-            emitLine(formatFailureLine(node.id, outcome.durationMs, colors))
+            // ◼ row now; the full frame replays at runEnd.
+            emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
             deferredFailures.push(
               formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
             )
@@ -615,11 +702,11 @@ export function defaultLogger(
           return
         case 'focused':
           if (isPrimary(node)) {
-            // Skipped tasks never started (upstream failed), so no
-            // frame-open fired — and a skip has no output, so a
-            // one-liner carries everything a frame would.
+            // Skipped tasks never started (blocked upstream, or the run
+            // stopped), so no frame-open fired — and a skip has no output,
+            // so a one-liner carries everything a frame would.
             if (outcome.status === 'skipped') {
-              emitLine(formatTaskSkippedLine(node, colors))
+              emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
               return
             }
             if (streamsLive(node)) {
@@ -640,7 +727,7 @@ export function defaultLogger(
             // to runEnd like everywhere else; everything else emits
             // ONE atomic block from the buffered output.
             if (outcome.status === 'failed') {
-              emitLine(formatFailureLine(node.id, outcome.durationMs, colors))
+              emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
               deferredFailures.push(
                 formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
               )
@@ -652,9 +739,9 @@ export function defaultLogger(
             return
           }
           // Dependency-pulled nodes: silent on success; failures get
-          // the ✗ marker now and their frame replayed at runEnd.
+          // the ◼ row now and their frame replayed at runEnd.
           if (outcome.status === 'failed') {
-            emitLine(formatFailureLine(node.id, outcome.durationMs, colors))
+            emitLine(formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(node)))
             deferredFailures.push(
               formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors),
             )
@@ -672,7 +759,7 @@ export function defaultLogger(
             return
           }
           if (outcome.status === 'skipped') {
-            emitLine(formatTaskSkippedLine(node, colors))
+            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
             return
           }
           const block = formatTaskBlock(node, outcome, { stdout, stderr, ...dropped }, colors)
@@ -685,10 +772,10 @@ export function defaultLogger(
             // 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); only the title
-              // carries user input.
+              // The message is ours (a literal, an integer and a signal
+              // name); only the title carries user input.
               emitBlock(
-                `::error title=${ghaProperty(node.id)}::failed (exit ${outcome.exitCode})\n${body}`,
+                `::error title=${ghaProperty(node.id)}::${failedLabel(outcome.exitCode, outcome.timedOut, outcome.sandboxViolations, outcome.notReady)}\n${body}`,
               )
             } else {
               emitBlock(