@vzn/vx 0.0.645 → 0.0.648

package/src/report/logger.ts

@@ -5,12 +5,18 @@ import {
   formatFrameOpen,
   formatKeptLines,
   formatPersistentTailBlock,
+  formatListHeader,
   formatTaskAbortedLine,
   formatTaskBlock,
   formatTaskExecutedLine,
   flakyNote,
+  pathNote,
+  whereNote,
+  formatTaskHashLine,
   formatTaskHitLine,
   formatTaskSkippedLine,
+  leavesStyle,
+  RESET,
   type OutputChunk,
 } from './framed-output.js'
 import {
@@ -26,8 +32,8 @@ import {
   formatSummarySection,
   neverStarted,
   ranUnsaved,
-  type CacheBucket,
   type RunContext,
+  type TaskBucket,
 } from './summary.js'
 import { isGroupTask } from '../graph/index.js'
 import {
@@ -38,7 +44,9 @@ import {
   tailText,
   type Tail,
   detectColors,
+  envFlagOn,
   type ColorSupport,
+  ui,
 } from '../util/index.js'
 import { isCacheHit } from '../graph/index.js'
 import { failedLabel, outcomeWord, ranNoCache } from './events.js'
@@ -164,11 +172,6 @@ export interface OutputView {
   ci?: boolean
 }
 
-/** CI=0 / CI=false count as "not CI" — several vendors use CI=true. */
-function truthyEnv(v: string | undefined): boolean {
-  return v !== undefined && v !== '' && v !== '0' && v !== 'false'
-}
-
 // ── GitHub Actions workflow-command escaping ────────────────────────
 // The runner parses `::`-prefixed LINES out of the log, so anything
 // interpolated into one has to be encoded or it changes the command's shape.
@@ -211,8 +214,8 @@ export function resolveOutputView(
   },
   env: Record<string, string | undefined> = process.env,
 ): OutputView {
-  const ci = truthyEnv(env['CI'])
-  const gha = truthyEnv(env['GITHUB_ACTIONS'])
+  const ci = envFlagOn(env['CI'])
+  const gha = envFlagOn(env['GITHUB_ACTIONS'])
   const mk = (mode: OutputView['mode']): OutputView => ({
     mode,
     ...(gha ? { gha: true } : {}),
@@ -231,7 +234,7 @@ export function resolveOutputView(
 const FORECAST_AFTER_MS = 1000
 /** A run shorter than this ends without a desktop notification. */
 const NOTIFY_AFTER_MS = 10_000
-// A step of vx's own quicker than this shows nowhere (M, 2026-10-15).
+// A step of vx's own quicker than this shows nowhere (2026-10-15).
 const STEP_SHOWN_MS = 150
 
 export function defaultLogger(
@@ -344,14 +347,15 @@ export function defaultLogger(
   let forecastFn: Forecast | undefined
   let graphForecast: (() => Forecast) | undefined
   let forecastTimer: ReturnType<typeof setTimeout> | null = null
-  let etaMs: number | undefined
+  // When the forecast says the run ends; past it, the region counts up.
+  let deadlineMs: number | undefined
   let critical: string | undefined
-  let blocks: ReadonlyMap<string, number> | undefined
+  // Tasks the region showed on the critical path: their finished rows say so too.
+  const onPath = new Set<string>()
+  let blockedCount = 0
   let expected: ReadonlyMap<string, number> | undefined
   let blocked: readonly BlockedTask[] | undefined
-  // The blocked task each idle worker row holds, by slot: a row keeps its
-  // task until it starts, in that row, or leaves the list, so nothing hops.
-  const heldRows: (string | null)[] = []
+  let blockedBy: ReadonlyMap<string, number> | undefined
   let etaAtMs = 0
   const signals = writer.enabled
     ? terminalSignals(opts.env ?? process.env)
@@ -360,18 +364,11 @@ export function defaultLogger(
   let progressShown = -1
   let progressRed = false
 
-  // Every interactive view renders the fixed-height worker region:
-  // one row per worker slot so a task's name never moves while it
-  // runs (the display derives from the stable worker set, not the
-  // churning task set). Sized at runStart from concurrency, capped at
-  // 10 rows; excess running tasks queue for a freed slot and surface
-  // as `+k more` on the stats line. Focused flow keeps its lifecycle:
-  // the region dies the moment a requested node starts streaming.
+  // Every interactive view renders the fixed-height running list: one
+  // row per worker, sized at runStart from concurrency, so its height
+  // never changes; a task keeps its slot for its whole life. Excess
+  // running tasks queue for a freed slot, each shown after the slots.
   let slots: (WorkerSlot | null)[] = []
-  // Rows shown: the most workers busy at once so far. An idle row past it
-  // was noise (a 10-core machine drew 9 on a one-chain run); it never
-  // shrinks, so a row never jumps.
-  let shownSlots = 0
   const slotQueue: WorkerSlot[] = []
   let succeeded = 0
   // Executed with no `cache` block: never a miss, counted apart.
@@ -383,12 +380,12 @@ export function defaultLogger(
   let notSaved = 0
   let skippedCount = 0
   // Each finished task's cache bucket by its key: its remote traffic moves it.
-  const buckets = new Map<string, CacheBucket>()
+  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 (M, 2026-10-15).
+  // footer and step rows, until the footer replaces it (2026-10-15).
   let tail = false
   // The run was stopped: the region stays, its running rows say
-  // `aborting`, and nothing is forecast or held (M, 2026-10-17).
+  // `aborting`, and nothing is forecast or held (2026-10-17).
   let stopping = false
   // Counted live once the run is stopping, as the footer counts them.
   let stopped = 0
@@ -410,7 +407,8 @@ export function defaultLogger(
   // deferred to runEnd (owner: '✗ line, continue, all full frames at
   // the end'). 'full'/CI keeps frames inline.
   const deferredFailures: string[] = []
-  const pinnedPersistent: string[] = []
+  // Each ready server's outcome: one whose child has exited (`serverExit`) is no longer pinned.
+  const pinnedPersistent: TaskOutcome[] = []
   let flushedFailures = false
   // A persistent task (dev server, watcher, daemon) is the one task kind
   // nothing bounds: a one-shot command's output ends when it exits, but a
@@ -467,21 +465,44 @@ export function defaultLogger(
   }
   const printsKept = (tail: { outcome?: TaskOutcome }): boolean =>
     flushedPersistent && tail.outcome !== undefined && view.mode !== 'errors-only'
+  // A server writing before this run started its task is one an earlier run
+  // left running (`vx watch` keeps its dev server): it streams as a kept
+  // one, live above the rows. Buffered as a task yet to run, it was never shown.
+  const heldOver = (node: TaskNode): boolean =>
+    node.config.exec?.persistent !== undefined && view.mode !== 'errors-only'
 
+  // A forced refresh the region has not been built for yet: the build
+  // takes the forecast pass the event asked for.
+  let forcePending = false
+  // The region is built when the writer draws it (`setRegion`'s function
+  // form), from the state as it is then: the events a forced-redraw floor
+  // coalesces build nothing.
   const refresh = (forced: boolean): void => {
     if (statusDead) return
-    let force = forced
+    const first = forecastFn === undefined && graphForecast !== undefined && !tail && !stopping
+    forcePending ||= forced || first
+    writer.setRegion(buildRegion, { force: forced || first })
+  }
+  const buildRegion = (): readonly string[] => {
+    let force = forcePending
+    forcePending = false
     const now = Date.now()
-    // A free row shows what it holds from the first frame: the graph
-    // knows, without history (M, 2026-10-17).
-    if (forecastFn === undefined && graphForecast !== undefined && !tail && !stopping)
-      for (let i = 0; i < shownSlots; i++)
-        if (slots[i] === null) {
-          forecastFn = graphForecast()
-          graphForecast = undefined
-          force = true
-          break
-        }
+    // A task its executor still holds has not begun: its clock starts at
+    // the first frame a machine runs it.
+    const where = runContext?.whereRunning
+    if (where !== undefined)
+      for (const x of [...slots, ...slotQueue]) {
+        if (x === null) continue
+        x.waiting = where(x.id) === null
+        if (x.waiting) x.startedMs = now
+      }
+    // The rows' blocked counts and planned tasks from the first frame: the
+    // graph knows, without history.
+    if (forecastFn === undefined && graphForecast !== undefined && !tail && !stopping) {
+      forecastFn = graphForecast()
+      graphForecast = undefined
+      force = true
+    }
     // Twice a second at most: one pass over the unfinished graph.
     if (forecastFn !== undefined && !tail && !stopping && (force || now - etaAtMs >= 500)) {
       etaAtMs = now
@@ -489,16 +510,23 @@ export function defaultLogger(
       for (const s of slots) if (s !== null) running.set(s.id, s.startedMs)
       for (const s of slotQueue) running.set(s.id, s.startedMs)
       const f = forecastFn(finished, running, now)
-      etaMs = f.etaMs
+      deadlineMs =
+        f.etaMs === undefined
+          ? undefined
+          : f.etaMs > 0
+            ? now + f.etaMs
+            : Math.min(deadlineMs ?? now, now)
       critical = f.critical
-      blocks = f.blocks
+      blockedCount = f.waiting
       expected = f.expected
       blocked = f.blocked
+      blockedBy = f.blockedBy
     }
+    const etaMs = deadlineMs === undefined ? undefined : deadlineMs - now
     if (signals.progress && total > 0) {
       const elapsed = now - startedAtMs
       const pct = Math.floor(
-        etaMs !== undefined && elapsed + etaMs > 0
+        etaMs !== undefined && etaMs > 0
           ? (elapsed / (elapsed + etaMs)) * 100
           : (done / total) * 100,
       )
@@ -509,6 +537,16 @@ export function defaultLogger(
         out.write(progressEscape(progressShown, progressRed))
       }
     }
+    let running = 0
+    let scheduled = 0
+    // Stopping, the rows say `aborting`: nothing is running or scheduled.
+    if (!tail && !stopping)
+      for (const x of [...slots, ...slotQueue]) {
+        if (x === null) continue
+        if (x.waiting === true) scheduled++
+        else running++
+      }
+    if (critical !== undefined && running > 0) onPath.add(critical)
     // The live summary IS the final summary's section, built from the
     // same formatter so the region visually becomes the printout.
     const summaryLines =
@@ -530,7 +568,14 @@ export function defaultLogger(
               miss: succeeded + failed - noCache,
               noCache,
               left: total - done - stopped - notRun,
-              ...(etaMs !== undefined && !tail && !stopping ? { etaMs } : {}),
+              ...(running > 0 ? { running } : {}),
+              ...(scheduled > 0 ? { scheduled } : {}),
+              ...(blockedCount > 0 && !tail && !stopping ? { blocked: blockedCount } : {}),
+              ...(etaMs !== undefined && !tail && !stopping
+                ? etaMs > 0
+                  ? { etaMs }
+                  : { overMs: -etaMs }
+                : {}),
               buckets,
               spread:
                 spreadCount > 0
@@ -541,59 +586,30 @@ export function defaultLogger(
             colors,
             runContext,
           )
-    const held = blocked === undefined || stopping ? undefined : holdRows(blocked)
     const shownSteps: WorkerSlot[] = []
     for (const [id, startedMs] of steps)
       if (now - startedMs >= STEP_SHOWN_MS) shownSteps.push({ id, startedMs })
-    writer.setRegion(
-      formatStatusRegion(
-        {
-          pinnedPersistent,
-          slots: slots.slice(0, shownSlots),
-          ...(held !== undefined ? { blocked: held } : {}),
-          overflow: slotQueue.length,
-          ...(stopping ? { stopping } : {}),
-          ...(shownSteps.length > 0 ? { steps: shownSteps } : {}),
-          nowMs: Date.now(),
-          summaryLines,
-          ...(blocks !== undefined ? { blocks } : {}),
-          ...(expected !== undefined ? { expected } : {}),
-          ...(critical !== undefined ? { critical } : {}),
-        },
-        colors,
-      ),
-      { force },
+    return formatStatusRegion(
+      {
+        pinnedPersistent: pinnedPersistent
+          .filter((o) => o.serverExit === undefined)
+          .map((o) => o.node.id),
+        // Every running task has a row: one beyond the slots follows them.
+        slots: [...slots, ...slotQueue],
+        size: slots.length,
+        ...(blocked !== undefined && !stopping ? { next: blocked } : {}),
+        ...(blockedBy !== undefined && !stopping ? { blockedBy } : {}),
+        ...(stopping ? { stopping } : {}),
+        ...(shownSteps.length > 0 ? { steps: shownSteps } : {}),
+        nowMs: Date.now(),
+        summaryLines,
+        ...(runContext?.whereRunning !== undefined ? { where: runContext.whereRunning } : {}),
+        ...(expected !== undefined ? { expected } : {}),
+        ...(critical !== undefined ? { critical } : {}),
+      },
+      colors,
     )
   }
-  // Each idle worker row holds a blocked task, in scheduler order. A row
-  // with none left to hold leaves the region (M, 2026-10-15): blocked tasks
-  // only dwindle, so it is never needed again, and the rows below close up.
-  const holdRows = (list: readonly BlockedTask[]): (BlockedTask | null)[] => {
-    const started = new Set<string>()
-    for (const s of slots) if (s !== null) started.add(s.id)
-    for (const s of slotQueue) started.add(s.id)
-    const open = new Map<string, BlockedTask>()
-    for (const b of list) if (!started.has(b.id)) open.set(b.id, b)
-    const rows: (BlockedTask | null)[] = []
-    for (let i = 0; i < shownSlots; i++) {
-      const kept = slots[i] === null ? open.get(heldRows[i] ?? '') : undefined
-      rows.push(kept ?? null)
-      if (kept !== undefined) open.delete(kept.id)
-    }
-    const rest = open.values()
-    for (let i = 0; i < shownSlots; i++)
-      if (slots[i] === null && rows[i] === null) rows[i] = rest.next().value ?? null
-    for (let i = shownSlots - 1; i >= 0; i--) {
-      if (slots[i] !== null || rows[i] !== null) continue
-      rows.splice(i, 1)
-      slots.splice(i, 1)
-      slots.push(null)
-      shownSlots--
-    }
-    heldRows.length = 0
-    for (const r of rows) heldRows.push(r?.id ?? null)
-    return rows
-  }
   const tick = (): void => {
     if (!writer.enabled || statusDead || ticker !== null) return
     // Keeps the per-worker elapsed time ticking between task events
@@ -624,14 +640,36 @@ export function defaultLogger(
   }
 
   // The task log opens with one blank line before its first row, on a
-  // terminal and off one (M, 2026-10-14). A note vx prints before it is
+  // terminal and off one (2026-10-14). A note vx prints before it is
   // no task row (`status`). Without a footer, the caller frames the log
   // (`vx watch` opens each cycle with its own line).
   let logOpened = opts.footer === false
   // The log ends on a blank line (a block's own): a blank status line
   // after it (the footer's) would make two; one blank line apart is the rule.
   let endsBlank = false
+  // A live-streamed task's partial line, and any colour it left on, end
+  // before anything of vx's own: a row or a block written after it (a step
+  // that ends while the task streams, another task's failure, a kept
+  // server's line) was glued to it, `building...      time status  cache
+  // task`, and took its colour.
+  let streamStyled = false
+  const endStreamLine = (): void => {
+    const end = (streamStyled ? RESET : '') + (streamMidLine ? '\n' : '')
+    streamStyled = false
+    streamMidLine = false
+    if (end.length > 0) logWrite(end)
+  }
   const taskWrite = (chunk: string): void => {
+    endStreamLine()
+    logWrite(chunk)
+  }
+  const streamWrite = (chunk: string): void => {
+    streamedSinceBlock = true
+    if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
+    if (chunk.includes('\x1b[')) streamStyled = leavesStyle(chunk)
+    logWrite(chunk)
+  }
+  const logWrite = (chunk: string): void => {
     if (chunk.length > 0) endsBlank = chunk.endsWith('\n\n')
     if (!logOpened && chunk.length > 0) {
       logOpened = true
@@ -644,10 +682,21 @@ export function defaultLogger(
     taskWrite(`${line}\n`)
     lineEmitted = true
   }
+  // The list's header, once over its first row, where the live region
+  // heads its own rows the same way (2026-10-21).
+  let headed = !writer.enabled
+  const emitRow = (line: string): void => {
+    if (!headed) {
+      headed = true
+      emitLine(formatListHeader(runContext?.whereRunning !== undefined, colors))
+    }
+    emitLine(line)
+  }
   // 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 => {
     if (block.length === 0) return
+    endStreamLine()
     const lead = lineEmitted || streamedSinceBlock ? '\n' : ''
     taskWrite(`${lead}${block}\n`)
     lineEmitted = false
@@ -684,6 +733,8 @@ export function defaultLogger(
 
   const failureRow = (node: TaskNode, outcome: TaskOutcome): string =>
     formatFailureLine(node.id, outcome.durationMs, colors, cacheWordOf(outcome)) +
+    (onPath.has(node.id) ? pathNote(colors) : '') +
+    whereNote(outcome, colors) +
     flakyNote(outcome, colors)
 
   return {
@@ -699,21 +750,15 @@ export function defaultLogger(
       flushKept()
       // A live-streamed server keeps writing after its frame closes, so a
       // summary row or "exited with code" can follow its partial line.
-      if (streamMidLine) {
-        writer.write('\n')
-        streamMidLine = false
-      }
+      endStreamLine()
       if (line === '' && endsBlank) return
       endsBlank = line === ''
       writer.write(`${line}\n`)
     },
     warn(line) {
       flushKept()
-      if (streamMidLine) {
-        writer.write('\n')
-        streamMidLine = false
-      }
-      writer.writeTo(errOut, `${line}\n`)
+      endStreamLine()
+      writer.writeTo(errOut, `${ui.tagged('warn', line, colors)}\n`)
     },
     runStart(info) {
       total = info.total
@@ -721,9 +766,7 @@ export function defaultLogger(
       runContext = info.context
       startedAtMs = Date.now()
       started = true
-      const cap = Math.max(1, Math.min(info.concurrency ?? 10, 10))
-      slots = Array.from({ length: cap }, () => null)
-      shownSlots = 0
+      slots = Array.from({ length: Math.max(1, info.concurrency ?? 10) }, () => null)
       tick()
       refresh(true)
     },
@@ -735,15 +778,20 @@ export function defaultLogger(
     stepEnd(id, { durationMs, ok }) {
       steps.delete(id)
       if (durationMs < STEP_SHOWN_MS) return
-      if (ok ? view.mode !== 'none' && view.mode !== 'errors-only' : view.mode !== 'none')
-        emitLine(formatStepLine(id, durationMs, ok, colors))
+      // `hash-only` is one line per task: only a step that failed adds one.
+      if (
+        ok
+          ? view.mode !== 'none' && view.mode !== 'errors-only' && view.mode !== 'hash-only'
+          : view.mode !== 'none'
+      )
+        emitRow(formatStepLine(id, durationMs, ok, colors))
       refresh(true)
     },
     runStop() {
       if (stopping) return
       stopping = true
       blocked = undefined
-      heldRows.length = 0
+      blockedBy = undefined
       refresh(true)
     },
     runDone() {
@@ -757,34 +805,25 @@ export function defaultLogger(
         // What is coalesced lands before the task writes past it.
         writer.settle()
       }
-      // Focused flow: the status line exists for the dependency
-      // phase only. The moment a requested node starts streaming,
-      // clear it for good — its raw output owns the terminal now.
+      // Focused flow: a requested node streams raw, and the region stays
+      // under its output (the writer erases and redraws it around each
+      // write): taken down, the summary and the run's id were gone until
+      // the task ended.
       if (streamsLive(node)) {
-        killStatus()
         // Open the live frame: full task info even when the command
         // streams nothing (or the hit replays nothing).
         emitLine(formatFrameOpen(node, colors, forwardArgs))
-        return
-      }
-      // Bound a persistent task's output from its FIRST chunk. Waiting for
-      // its outcome would leave a never-ready one uncapped forever.
-      if (node.config.exec?.persistent !== undefined && !persistentTails.has(node.id)) {
+      } else if (node.config.exec?.persistent !== undefined && !persistentTails.has(node.id)) {
+        // Bound a persistent task's output from its FIRST chunk. Waiting for
+        // its outcome would leave a never-ready one uncapped forever.
         persistentTails.set(node.id, { node, out: createTail(), err: createTail() })
       }
+      // The rows are the status region's; with none, nothing reads them.
+      if (statusDead) return
       const slot: WorkerSlot = { id: node.id, startedMs: Date.now() }
-      // A blocked task starts in the row that held it; another takes a free
-      // row, else the last held one, whose task moves to the next free row.
-      const own = heldRows.indexOf(node.id)
-      let free = own >= 0 && slots[own] === null ? own : -1
-      if (free < 0)
-        free = slots.findIndex((s, i) => s === null && i < shownSlots && heldRows[i] == null)
-      if (free < 0) free = slots.findLastIndex((s, i) => s === null && i < shownSlots)
-      if (free < 0) free = slots.indexOf(null)
-      if (free >= 0) {
-        slots[free] = slot
-        shownSlots = Math.max(shownSlots, free + 1)
-      } else slotQueue.push(slot)
+      const free = slots.indexOf(null)
+      if (free >= 0) slots[free] = slot
+      else slotQueue.push(slot)
       refresh(true)
     },
     holdStatus: () => writer.hold(),
@@ -821,7 +860,7 @@ export function defaultLogger(
         tail = true
         slots = []
         blocked = undefined
-        shownSlots = 0
+        blockedBy = undefined
         slotQueue.length = 0
         refresh(true)
       } else if (!tail) killStatus()
@@ -880,9 +919,7 @@ export function defaultLogger(
     taskStdout(node, chunk) {
       if (discardsOutput) return
       if (streamsLive(node)) {
-        streamedSinceBlock = true
-        if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
-        taskWrite(chunk)
+        streamWrite(chunk)
         return
       }
       const tail = persistentTails.get(node.id)
@@ -891,14 +928,13 @@ export function defaultLogger(
         else appendTail(tail.out, chunk)
         return
       }
+      if (heldOver(node)) return streamKept(node, chunk)
       pushChunk(node.id, chunk, false)
     },
     taskStderr(node, chunk) {
       if (discardsOutput) return
       if (streamsLive(node)) {
-        streamedSinceBlock = true
-        if (chunk.length > 0) streamMidLine = !chunk.endsWith('\n')
-        taskWrite(chunk)
+        streamWrite(chunk)
         return
       }
       const tail = persistentTails.get(node.id)
@@ -907,6 +943,7 @@ export function defaultLogger(
         else appendTail(tail.err, chunk)
         return
       }
+      if (heldOver(node)) return streamKept(node, chunk)
       pushChunk(node.id, chunk, true)
     },
     taskComplete(node, outcome) {
@@ -957,23 +994,21 @@ export function defaultLogger(
             (view.mode === 'focused' && isPrimary(node)) ||
             (framesTerminal && holdsTerminal(node)))
         if (framed && streamsLive(node)) {
-          if (streamMidLine) {
-            taskWrite('\n')
-            streamMidLine = false
-          }
           emitFrameClose(formatFrameClose(node, outcome, colors))
           return
         }
         if (framed && output.some((c) => c.text.length > 0)) {
           emitBlock(
-            formatTaskBlock(
-              node,
-              outcome,
-              { output, ...dropped },
-              colors,
-              true,
-              forwardArgs,
-              links,
+            fenced(
+              formatTaskBlock(
+                node,
+                outcome,
+                { output, ...dropped },
+                colors,
+                true,
+                forwardArgs,
+                links,
+              ),
             ),
           )
           return
@@ -981,7 +1016,7 @@ export function defaultLogger(
         // Otherwise a row in the task list, in every view that lists a
         // failure: the run exits red, and the row names why.
         if (view.mode !== 'none' && view.mode !== 'hash-only') {
-          emitLine(formatTaskAbortedLine(node, outcome, colors))
+          emitRow(formatTaskAbortedLine(node, outcome, colors))
         }
         return
       }
@@ -995,7 +1030,7 @@ export function defaultLogger(
           // A persistent task's outcome arrives at READY; the child
           // keeps running until the orchestrator SIGTERMs it at run
           // end — pin it so its liveness stays visible.
-          pinnedPersistent.push(node.id)
+          pinnedPersistent.push(outcome)
           // …and capture what it writes from here on. A live-streaming
           // node already owns the terminal, so buffering it would emit
           // its output twice.
@@ -1005,16 +1040,19 @@ export function defaultLogger(
         }
         // Free the task's slot; the longest-waiting queued task
         // (if any) takes it over, keeping lowest-index-first reuse.
-        const si = slots.findIndex((s) => s !== null && s.id === node.id)
-        if (si >= 0) slots[si] = slotQueue.shift() ?? null
-        else {
-          const qi = slotQueue.findIndex((s) => s.id === node.id)
-          if (qi >= 0) slotQueue.splice(qi, 1)
+        if (!statusDead) {
+          const si = slots.findIndex((s) => s !== null && s.id === node.id)
+          if (si >= 0) slots[si] = slotQueue.shift() ?? null
+          else {
+            const qi = slotQueue.findIndex((s) => s.id === node.id)
+            if (qi >= 0) slotQueue.splice(qi, 1)
+          }
         }
         const bucket = cacheBucketOf(outcome)
         if (bucket !== undefined) {
-          if (outcome.hash !== undefined) buckets.set(outcome.hash, bucket)
-          buckets.set(node.id, bucket)
+          const entry = { task: node.id, bucket }
+          if (outcome.hash !== undefined) buckets.set(outcome.hash, entry)
+          buckets.set(node.id, entry)
         }
         switch (outcome.status) {
           case 'success':
@@ -1045,10 +1083,6 @@ export function defaultLogger(
       }
       if (isGroupTask(node)) return
       if (holdsTerminal(node) && streamsLive(node) && outcome.status !== 'skipped') {
-        if (streamMidLine) {
-          taskWrite('\n')
-          streamMidLine = false
-        }
         emitFrameClose(formatFrameClose(node, outcome, colors))
         return
       }
@@ -1060,17 +1094,16 @@ export function defaultLogger(
           // The word carries the outcome (skips/failures included); the
           // key is what this mode exists to show — absent for a task
           // that never computed one (skipped, uncacheable).
-          const key = outcome.hash === undefined ? '' : ` ${outcome.hash}`
-          emitLine(`${outcomeWord(outcome)} ${node.id}${key}`)
+          emitLine(formatTaskHashLine(node, outcome, colors))
           return
         }
         case 'errors-only':
           if (outcome.status === 'skipped') {
-            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
+            emitRow(formatTaskSkippedLine(node, colors, outcome))
             return
           }
           if (outcome.status !== 'failed') return
-          emitLine(failureRow(node, outcome))
+          emitRow(failureRow(node, outcome))
           deferredFailures.push(
             formatTaskBlock(
               node,
@@ -1090,7 +1123,7 @@ export function defaultLogger(
           // surface in the end-of-run summary.
           if (outcome.status === 'failed') {
             // ◼ row now; the full frame replays at runEnd.
-            emitLine(failureRow(node, outcome))
+            emitRow(failureRow(node, outcome))
             deferredFailures.push(
               formatTaskBlock(
                 node,
@@ -1103,9 +1136,9 @@ export function defaultLogger(
               ),
             )
           } else if (outcome.status === 'success') {
-            emitLine(formatTaskExecutedLine(node, outcome, colors))
+            emitRow(formatTaskExecutedLine(node, outcome, colors, onPath.has(node.id)))
           } else if (outcome.status === 'skipped') {
-            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
+            emitRow(formatTaskSkippedLine(node, colors, outcome))
           }
           return
         case 'focused':
@@ -1114,7 +1147,7 @@ export function defaultLogger(
             // 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, outcome.blockedBy))
+              emitRow(formatTaskSkippedLine(node, colors, outcome))
               return
             }
             if (streamsLive(node)) {
@@ -1123,10 +1156,6 @@ export function defaultLogger(
               // this close — full task info for every outcome, cached
               // and up-to-date included (owner: "always full frame
               // for a single task").
-              if (streamMidLine) {
-                taskWrite('\n')
-                streamMidLine = false
-              }
               emitFrameClose(formatFrameClose(node, outcome, colors))
               return
             }
@@ -1135,7 +1164,7 @@ export function defaultLogger(
             // to runEnd like everywhere else; everything else emits
             // ONE atomic block from the buffered output.
             if (outcome.status === 'failed') {
-              emitLine(failureRow(node, outcome))
+              emitRow(failureRow(node, outcome))
               deferredFailures.push(
                 formatTaskBlock(
                   node,
@@ -1152,14 +1181,16 @@ export function defaultLogger(
             // forceCommand: a requested task's frame shows `$ cmd`
             // whether it ran or was cached — same frame every run.
             emitBlock(
-              formatTaskBlock(
-                node,
-                outcome,
-                { output, ...dropped },
-                colors,
-                true,
-                forwardArgs,
-                links,
+              fenced(
+                formatTaskBlock(
+                  node,
+                  outcome,
+                  { output, ...dropped },
+                  colors,
+                  true,
+                  forwardArgs,
+                  links,
+                ),
               ),
             )
             return
@@ -1167,9 +1198,9 @@ export function defaultLogger(
           // Dependency-pulled nodes: silent on success; a skip gets its
           // row, failures the ◼ row now and their frame replayed at runEnd.
           if (outcome.status === 'skipped') {
-            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
+            emitRow(formatTaskSkippedLine(node, colors, outcome))
           } else if (outcome.status === 'failed') {
-            emitLine(failureRow(node, outcome))
+            emitRow(failureRow(node, outcome))
             deferredFailures.push(
               formatTaskBlock(
                 node,
@@ -1191,11 +1222,11 @@ export function defaultLogger(
           // point); misses/failures are always framed. One-liners
           // stay outside ::group:: — there's nothing to collapse.
           if (isHit && output.every((c) => c.text.trim().length === 0)) {
-            emitLine(formatTaskHitLine(node, outcome, colors))
+            emitRow(formatTaskHitLine(node, outcome, colors, onPath.has(node.id)))
             return
           }
           if (outcome.status === 'skipped') {
-            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
+            emitRow(formatTaskSkippedLine(node, colors, outcome))
             return
           }
           const block = formatTaskBlock(