@vzn/vx 0.0.646 → 0.0.649

package/src/report/events.ts

@@ -9,7 +9,7 @@
 import { exitSignal } from '../exec/index.js'
 import type { InputChanges, TaskNode, TaskOutcome } from '../graph/index.js'
 import { isGroupTask } from '../graph/index.js'
-import { maskedCommand, secretMask } from '../util/index.js'
+import { heldSecrets, maskedCommand, type SecretMask, secretMask } from '../util/index.js'
 import type { Logger } from './logger.js'
 import type { RunContext } from './summary.js'
 
@@ -122,10 +122,19 @@ export function busLogger(bus: EventBus): Logger {
   let done = false
   // A status line carries plugin warnings, and a remote layer's warning
   // quotes the server's reply, which may echo what it was sent (L-40).
-  const secrets = secretMask([process.env])
+  // Built again once a plugin's keychain answered: its token is in no env.
+  let secrets: SecretMask | null = null
+  let built = -1
+  const masked = (line: string): string => {
+    if (built !== heldSecrets()) {
+      built = heldSecrets()
+      secrets = secretMask([process.env])
+    }
+    return secrets?.mask(line) ?? line
+  }
   return {
-    status: (line) => bus.emit({ kind: 'run:status', line: secrets?.mask(line) ?? line }),
-    warn: (line) => bus.emit({ kind: 'run:status', line: secrets?.mask(line) ?? line, warn: true }),
+    status: (line) => bus.emit({ kind: 'run:status', line: masked(line) }),
+    warn: (line) => bus.emit({ kind: 'run:status', line: masked(line), warn: true }),
     taskStdout: (node, chunk) => bus.emit({ kind: 'task:stdout', node, chunk }),
     taskStderr: (node, chunk) => bus.emit({ kind: 'task:stderr', node, chunk }),
     taskComplete: (node, outcome) => bus.emit({ kind: 'task:complete', node, outcome }),
@@ -212,7 +221,7 @@ export function terminalSubscriber(sink: Logger): RunEventSubscriber {
 export function wireForwarder(send: (event: WireEvent) => void): RunEventSubscriber {
   // Which tasks the consumer has been told about. A skipped task never
   // reaches the scheduler's onStart, so its completion arrives with no
-  // preceding task:start — and `createWireRenderer` resolves a completion's
+  // preceding task:start — and a consumer resolves a completion's
   // node from the start it recorded, so it would drop the task entirely
   // while the forwarded footer still counted it. Synthesize the start here,
   // where the live TaskNode is in hand, so the projection stays full
@@ -292,6 +301,8 @@ export interface OutcomeView {
   /** A skipped task: the failed (or aborted) task at the root of the block
    *  (see `TaskOutcome`); absent for fail-fast's skip, which nothing blocked. */
   blockedBy?: string
+  /** A skipped task whose `exec.platforms` leave out this machine (see `TaskOutcome`). */
+  otherPlatform?: { readonly needs: readonly string[]; readonly host: string }
   /** How long an `admit` policy held the task with a worker free (see `TaskOutcome`). */
   admissionHeldMs?: number
   /** How long the task waited ready for a worker (see `TaskOutcome`). */
@@ -319,7 +330,8 @@ export interface OutcomeView {
  * header and footer, the focused one-liner, the hash-only audit line,
  * the verbose summary table: `success` / `restored-local` /
  * `restored-remote` / `up-to-date` / `failed` / `skipped`. A hit that
- * materialized nothing is up-to-date whichever layer answered.
+ * materialized nothing is up-to-date; a remote hit always restored
+ * (`hitOutcome`), so it is never up to date.
  */
 export function outcomeWord(o: Pick<OutcomeView, 'status' | 'restored'>): string {
   switch (o.status) {
@@ -344,26 +356,32 @@ export function outcomeLabel(
     | 'notReady'
     | 'inputMoved'
     | 'blockedBy'
+    | 'otherPlatform'
   >,
 ): string {
   if (o.status === 'failed')
     return failedLabel(o.exitCode, o.timedOut, o.sandboxViolations, o.notReady, o.inputMoved)
-  if (o.status === 'skipped') return skippedLabel(o.blockedBy)
+  if (o.status === 'skipped') return skippedLabel(o)
   return outcomeWord(o)
 }
 
 /**
- * Why a task was skipped, one copy for every surface: `blocked by lib#build`
- * (the failed or aborted task at the root of the block), or '' for fail-fast's skip — the run stopped,
+ * Why a task was skipped, one copy for every surface: `needs darwin-arm64,
+ * this is linux-x64` (its `exec.platforms`), `blocked by lib#build` (the
+ * task at the root of the block), or '' for fail-fast's skip — the run stopped,
  * nothing blocked it, and a label claiming an upstream failure would lie.
  */
-export function skippedReason(blockedBy: string | undefined): string {
-  return blockedBy === undefined ? '' : `blocked by ${blockedBy}`
+export function skippedReason(o: SkipView = {}): string {
+  if (o.otherPlatform !== undefined)
+    return `needs ${o.otherPlatform.needs.join(' or ')}, this is ${o.otherPlatform.host}`
+  return o.blockedBy === undefined ? '' : `blocked by ${o.blockedBy}`
 }
 
+type SkipView = Pick<OutcomeView, 'blockedBy' | 'otherPlatform'>
+
 /** `skipped (blocked by lib#build)`, or a bare `skipped` for fail-fast's. */
-function skippedLabel(blockedBy: string | undefined): string {
-  const why = skippedReason(blockedBy)
+function skippedLabel(o: SkipView): string {
+  const why = skippedReason(o)
   return why === '' ? 'skipped' : `skipped (${why})`
 }
 
@@ -448,6 +466,7 @@ export function projectOutcome(outcome: TaskOutcome): OutcomeView {
   if (outcome.notReady !== undefined) view.notReady = outcome.notReady
   if (outcome.inputMoved !== undefined) view.inputMoved = outcome.inputMoved
   if (outcome.blockedBy !== undefined) view.blockedBy = outcome.blockedBy
+  if (outcome.otherPlatform !== undefined) view.otherPlatform = outcome.otherPlatform
   if (outcome.restored !== undefined) view.restored = outcome.restored
   if (outcome.sandboxViolations !== undefined) view.sandboxViolations = outcome.sandboxViolations
   if (outcome.sandboxViolationLines !== undefined)

package/src/report/forecast.ts

@@ -17,9 +17,16 @@ export interface LiveForecast {
   /**
    * Tasks not started because a dependency has not finished, in the order
    * the scheduler would start them, at most one per worker: what an idle
-   * worker row holds (M, 2026-10-15).
+   * worker row holds (2026-10-15).
    */
   blocked?: readonly BlockedTask[]
+  /**
+   * Each running task's count of the tasks not started that depend on it
+   * directly (through a group, which runs nothing): its row's `blocked`
+   * cell, why they are not running. A task waiting on two running tasks
+   * counts under both.
+   */
+  blockedBy: ReadonlyMap<string, number>
 }
 
 /** A task an unfinished dependency holds back, and what holds it: the running task its longest chain waits on, else that dependency. */
@@ -34,16 +41,13 @@ export type Forecast = (
   nowMs: number,
 ) => LiveForecast
 
-/** How far past its p50 a running task may go before the forecast gives up. */
-const OVERRUN = 1.25
-
 /**
  * The later of the longest unfinished chain and the unfinished work spread
  * over the workers. A task still to run costs its p50 (a pending task may
  * yet hit, so this leans long, and the hits finish first); a running one
  * costs what its p50 has left, never below zero; a group or a task with no
- * history costs nothing. A running task well past its p50 means history
- * no longer describes this run, and the forecast says nothing of time.
+ * history costs nothing. Zero while tasks still run means the run is past
+ * its estimate: the live region counts the time since (2026-10-27).
  */
 export function createForecast(
   nodes: ReadonlyMap<string, TaskNode>,
@@ -84,6 +88,22 @@ export function createForecast(
   // graph order: once per run, as the scheduler computes it.
   const rank = computeReverseDepCount(nodes)
   const position = new Map(order.map((n, i) => [n.id, i]))
+  // The tasks each node waits on directly, a group's own looked through.
+  const direct = new Map<string, readonly string[]>()
+  const through = (id: string, into: Set<string>, seen: Set<string>): void => {
+    if (seen.has(id)) return
+    seen.add(id)
+    const d = nodes.get(id)
+    if (d === undefined || !isGroupTask(d)) into.add(id)
+    else for (const x of d.deps) through(x, into, seen)
+  }
+  for (const n of order) {
+    if (isGroupTask(n) || n.deps.length === 0) continue
+    const into = new Set<string>()
+    const seen = new Set<string>()
+    for (const d of n.deps) through(d, into, seen)
+    direct.set(n.id, [...into])
+  }
   const before = (a: string, b: string): boolean => {
     const d = (rank.get(a) ?? 0) - (rank.get(b) ?? 0)
     return d !== 0 ? d > 0 : position.get(a)! < position.get(b)!
@@ -103,9 +123,9 @@ export function createForecast(
     let chainEnd: string | undefined
     let work = 0
     let known = false
-    let overrun = false
     // The best `workers` blocked tasks, kept sorted as the pass meets them.
     const held: BlockedTask[] = []
+    const blockedBy = new Map<string, number>()
     for (const n of order) {
       if (finished.has(n.id)) continue
       let start = 0
@@ -124,6 +144,8 @@ export function createForecast(
         since === undefined ? (head.get(n.id) ?? n.deps.find((d) => end.has(d))) : undefined
       if (by !== undefined && !isGroupTask(n)) {
         waiting++
+        for (const on of direct.get(n.id) ?? [])
+          if (running.has(on)) blockedBy.set(on, (blockedBy.get(on) ?? 0) + 1)
         let at = held.length
         while (at > 0 && before(n.id, held[at - 1]!.id)) at--
         if (at < workers) {
@@ -135,7 +157,6 @@ export function createForecast(
       let own = 0
       if (p !== undefined) {
         known = true
-        if (since !== undefined && nowMs - since > p * OVERRUN) overrun = true
         own = since === undefined ? p : Math.max(0, p - (nowMs - since))
       }
       const e = start + own
@@ -146,7 +167,7 @@ export function createForecast(
       }
       work += own
     }
-    if (!known || overrun) return { waiting, expected, blocked: held }
+    if (!known) return { waiting, expected, blocked: held, blockedBy }
     const critical = chainEnd === undefined ? undefined : head.get(chainEnd)
     return {
       etaMs: Math.max(chain, work / workers),
@@ -154,6 +175,7 @@ export function createForecast(
       waiting,
       expected,
       blocked: held,
+      blockedBy,
     }
   }
 }

package/src/report/framed-output.ts

@@ -32,22 +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
@@ -99,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
@@ -126,11 +142,18 @@ export function formatTaskBlock(
   lines.push(...violationSection(outcome, colors))
 
   lines.push(
-    `${corner('└─')} ${idPainted}${whereNote(outcome, colors)} ${corner('──')}${formatBlockFooter(outcome, colors)}`,
+    `${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
@@ -147,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('')
 }
 
@@ -171,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
@@ -194,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('')
 }
 
@@ -207,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}`
 }
 
@@ -263,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 })
 }
 
@@ -358,20 +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 dim header over a task list, on the row grid (M, 2026-10-21).
- * `agent` when an executor places tasks: the name after the id's dot.
+ * 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(agent: boolean, colors: ColorSupport = NO_COLOR): string {
-  const head = `   ${'time'.padStart(TIME_COL)} ${'status'.padEnd(STATUS_COL)} ${'cache'.padEnd(CACHE_COL)} task${agent ? ' \u00b7 agent' : ''}`
-  return paint('', head, colors, { dim: true })
+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. */
@@ -384,6 +427,21 @@ export function formatTaskHitLine(
   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. */
 export function formatTaskExecutedLine(
   node: TaskNode,
@@ -423,17 +481,17 @@ function formatOutcomeRow(
 
 /** `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(WARN, 'critical path', colors)}`
+  return `  ${paint(ERROR, 'critical path', colors)}`
 }
 
-/** Where an executor ran the task, when not here, right after its id: `@small#2` (M, 2026-10-21). */
+/** 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 an agent's name has no width to pad to (M, 2026-10-21).
+ * 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)}`
@@ -465,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(
@@ -532,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}`
 }
 
@@ -541,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
@@ -552,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)
@@ -569,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(', ')}`,
+                ),
+              ]
             : []),
           '',
         ]
@@ -595,14 +659,13 @@ 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 })}${whereNote(outcome, colors)} ${corner('──')}${tail}`
   const violations = violationSection(outcome, colors)
@@ -618,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)}`
 }
 
 /**
@@ -661,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
@@ -698,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)
   }
@@ -723,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 })
   }
 }
 
@@ -736,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,