@vzn/vx 0.0.645 → 0.0.646

package/src/orchestrator/telemetry.ts

@@ -16,7 +16,7 @@
 // what or how tasks run. Contrast `cache`/`executor`, which return objects
 // core calls INTO; those are the behavior capabilities, kept separate.
 
-import { sampleTrees } from '../exec/index.js'
+import { sampleTrees, type MachineReport } from '../exec/index.js'
 import {
   type CacheSource,
   deriveCacheSource,
@@ -274,6 +274,12 @@ export interface RunSummaryRecord {
    * Absent when nothing was uploaded or tried. Additive.
    */
   uploads?: { count: number; bytes: number; ms: number; failed: number }
+  /**
+   * The machines an executor plugin ran tasks on, with what each did
+   * (`TaskExecutor.machines`); a task's `where` names one. Absent when no
+   * executor reports any. Additive.
+   */
+  machines?: readonly MachineReport[]
 }
 
 /** One stage of a run, a wall window in epoch ms. */
@@ -305,6 +311,7 @@ export function assembleRunSummary(
     abortedCount: number
     stages?: readonly RunStage[]
     uploads?: { count: number; bytes: number; ms: number; failed: number }
+    machines?: readonly MachineReport[]
   },
 ): RunSummaryRecord {
   let failedCount = 0
@@ -343,6 +350,9 @@ export function assembleRunSummary(
     ...(timing.uploads !== undefined && timing.uploads.count + timing.uploads.failed > 0
       ? { uploads: { ...timing.uploads } }
       : {}),
+    ...(timing.machines !== undefined && timing.machines.length > 0
+      ? { machines: timing.machines }
+      : {}),
   }
 }
 
@@ -400,8 +410,19 @@ export interface TelemetrySource {
    * Sample this task's process tree every `SAMPLE_MS` until the returned
    * function is called, the root exits, or the run ends. Present only when
    * a sink wants `task.sample`: nobody asking costs no timer and no read.
+   * The returned stop answers what the samples saw, for the run history.
    */
-  readonly track?: (taskId: string, pid: number) => () => void
+  readonly track?: (taskId: string, pid: number) => () => TreeLoad | undefined
+}
+
+/**
+ * What a tracked task's samples saw: the most cores one interval between
+ * looks burned, and the mean resident memory over the looks. Undefined
+ * when no look landed (a task shorter than `SAMPLE_MS`).
+ */
+export interface TreeLoad {
+  peakCores: number
+  avgRssBytes: number
 }
 
 /** How often a running task's process tree is sampled. */
@@ -476,10 +497,18 @@ export function createTelemetrySource(args: {
   const wantsLog = sinks.some((s) => (s.wants ?? DEFAULT_KINDS).includes('task.log'))
   const wantsSample = sinks.some((s) => (s.wants ?? DEFAULT_KINDS).includes('task.sample'))
 
-  // taskId → the pid of its running root. One timer for every task, alive
-  // only while one runs; a tick still reading when the next is due is not
-  // doubled.
-  const tracked = new Map<string, number>()
+  // taskId → its running root and what the looks at it saw. One timer for
+  // every task, alive only while one runs; a tick still reading when the
+  // next is due is not doubled.
+  interface Tracked {
+    pid: number
+    lastTs: number
+    lastCpuMs: number
+    peakCores: number
+    rssSum: number
+    looks: number
+  }
+  const tracked = new Map<string, Tracked>()
   const every = args.every ?? everyInterval
   let stopEvery: (() => void) | undefined
   let sampling = false
@@ -488,8 +517,8 @@ export function createTelemetrySource(args: {
     stopEvery?.()
     stopEvery = undefined
   }
-  const untrack = (taskId: string, pid: number): void => {
-    if (tracked.get(taskId) === pid) tracked.delete(taskId)
+  const untrack = (taskId: string, t: Tracked): void => {
+    if (tracked.get(taskId) === t) tracked.delete(taskId)
     if (tracked.size === 0) stopTimer()
   }
   const tick = async (): Promise<void> => {
@@ -497,15 +526,23 @@ export function createTelemetrySource(args: {
     sampling = true
     try {
       const entries = [...tracked]
-      const usage = await sampleTrees(entries.map(([, pid]) => pid))
+      const usage = await sampleTrees(entries.map(([, t]) => t.pid))
       const ts = Date.now()
-      for (const [taskId, pid] of entries) {
-        if (ended || tracked.get(taskId) !== pid) continue
-        const u = usage.get(pid)
+      for (const [taskId, t] of entries) {
+        if (ended || tracked.get(taskId) !== t) continue
+        const u = usage.get(t.pid)
         if (u === undefined) {
-          untrack(taskId, pid)
+          untrack(taskId, t)
           continue
         }
+        // A descendant that exited takes its CPU out of the live sum, so an
+        // interval can read negative: it says nothing of the peak.
+        const ms = ts - t.lastTs
+        if (ms > 0) t.peakCores = Math.max(t.peakCores, (u.cpuMs - t.lastCpuMs) / ms)
+        t.lastTs = ts
+        t.lastCpuMs = u.cpuMs
+        t.rssSum += u.rssBytes
+        t.looks++
         deliver({
           v: TELEMETRY_SCHEMA_VERSION,
           kind: 'task.sample',
@@ -522,11 +559,17 @@ export function createTelemetrySource(args: {
       sampling = false
     }
   }
-  const track = (taskId: string, pid: number): (() => void) => {
-    if (ended) return () => {}
-    tracked.set(taskId, pid)
+  const track = (taskId: string, pid: number): (() => TreeLoad | undefined) => {
+    if (ended) return () => undefined
+    const t: Tracked = { pid, lastTs: Date.now(), lastCpuMs: 0, peakCores: 0, rssSum: 0, looks: 0 }
+    tracked.set(taskId, t)
     stopEvery ??= every(SAMPLE_MS, tick)
-    return () => untrack(taskId, pid)
+    return () => {
+      untrack(taskId, t)
+      return t.looks === 0
+        ? undefined
+        : { peakCores: t.peakCores, avgRssBytes: Math.round(t.rssSum / t.looks) }
+    }
   }
 
   function deliver(record: TelemetryRecord): void {

package/src/report/forecast.ts

@@ -10,8 +10,8 @@ export interface LiveForecast {
   etaMs?: number
   /** The running task at the head of the longest unfinished chain. */
   critical?: string
-  /** Each running task's unfinished dependents, direct and transitive. */
-  blocks: ReadonlyMap<string, number>
+  /** Tasks not started because a dependency has not finished: the tasks line's `blocked`. */
+  waiting: number
   /** Each running task's p50, where history knows it: the row's expected duration. */
   expected?: ReadonlyMap<string, number>
   /**
@@ -89,32 +89,10 @@ export function createForecast(
     return d !== 0 ? d > 0 : position.get(a)! < position.get(b)!
   }
 
-  const dependents = new Map<string, string[]>()
-  for (const n of order)
-    for (const d of n.deps) {
-      const list = dependents.get(d)
-      if (list === undefined) dependents.set(d, [n.id])
-      else list.push(n.id)
-    }
-
-  const blocked = (id: string, finished: ReadonlySet<string>): number => {
-    const seen = new Set<string>()
-    const stack = [id]
-    while (stack.length > 0) {
-      for (const next of dependents.get(stack.pop()!) ?? []) {
-        if (seen.has(next) || finished.has(next)) continue
-        seen.add(next)
-        stack.push(next)
-      }
-    }
-    return seen.size
-  }
-
   return (finished, running, nowMs) => {
-    const blocks = new Map<string, number>()
     const expected = new Map<string, number>()
+    let waiting = 0
     for (const id of running.keys()) {
-      blocks.set(id, blocked(id, finished))
       const p = cost.get(id)
       if (p !== undefined) expected.set(id, p)
     }
@@ -145,6 +123,7 @@ export function createForecast(
       const by =
         since === undefined ? (head.get(n.id) ?? n.deps.find((d) => end.has(d))) : undefined
       if (by !== undefined && !isGroupTask(n)) {
+        waiting++
         let at = held.length
         while (at > 0 && before(n.id, held[at - 1]!.id)) at--
         if (at < workers) {
@@ -167,12 +146,12 @@ export function createForecast(
       }
       work += own
     }
-    if (!known || overrun) return { blocks, expected, blocked: held }
+    if (!known || overrun) return { waiting, expected, blocked: held }
     const critical = chainEnd === undefined ? undefined : head.get(chainEnd)
     return {
       etaMs: Math.max(chain, work / workers),
       ...(critical !== undefined ? { critical } : {}),
-      blocks,
+      waiting,
       expected,
       blocked: held,
     }

package/src/report/framed-output.ts

@@ -32,6 +32,7 @@ import {
   identityColor,
   maskedCommand,
   paint,
+  ui,
   type ColorSupport,
 } from '../util/index.js'
 import { neverStarted } from './summary.js'
@@ -124,7 +125,9 @@ export function formatTaskBlock(
 
   lines.push(...violationSection(outcome, colors))
 
-  lines.push(`${corner('└─')} ${idPainted} ${corner('──')}${formatBlockFooter(outcome, colors)}`)
+  lines.push(
+    `${corner('└─')} ${idPainted}${whereNote(outcome, colors)} ${corner('──')}${formatBlockFooter(outcome, colors)}`,
+  )
   return lines.join('\n') + '\n'
 }
 
@@ -362,13 +365,23 @@ export function formatTaskRow(
   return ` ${glyph} ${timeCell(ms, colors)} ${st} ${ca} ${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.
+ */
+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 })
+}
+
 /** Compact one-liner for a cache hit with nothing to replay. */
 export function formatTaskHitLine(
   node: TaskNode,
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
+  onPath = false,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath)
 }
 
 /** Compact one-liner for an executed task in broad mode. */
@@ -376,8 +389,9 @@ export function formatTaskExecutedLine(
   node: TaskNode,
   o: TaskOutcome,
   colors: ColorSupport = NO_COLOR,
+  onPath = false,
 ): string {
-  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors)
+  return formatOutcomeRow(o, paintTaskId(node, colors), o.durationMs, colors, onPath)
 }
 
 /** Shared: render any outcome on the grid. */
@@ -386,6 +400,7 @@ function formatOutcomeRow(
   paintedId: string,
   ms: number | null,
   colors: ColorSupport,
+  onPath: boolean,
 ): string {
   const st = statusOf(o)
   const ca = cacheOf(o)
@@ -399,10 +414,31 @@ function formatOutcomeRow(
       ca.color,
       paintedId,
       colors,
-    ) + flakyNote(o, colors)
+    ) +
+    (onPath ? pathNote(colors) : '') +
+    whereNote(o, colors) +
+    flakyNote(o, colors)
   )
 }
 
+/** `critical path`: the row's task held the run's end while others ran beside it. */
+export function pathNote(colors: ColorSupport = NO_COLOR): string {
+  return `  ${paint(WARN, 'critical path', colors)}`
+}
+
+/** Where an executor ran the task, when not here, right after its id: `@small#2` (M, 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).
+ */
+export function placeNote(where: string, colors: ColorSupport = NO_COLOR): string {
+  return `${paint('', ' \u00b7', colors, { dim: true })} ${ui.inline(ui.place(where), colors)}`
+}
+
 /**
  * The dim note a flaky task's row and frame carry (`flaky - failed 1×
  * before`): nothing prints below the footer, so the task's own line is
@@ -568,7 +604,7 @@ export function formatFrameClose(
     persistent && outcome.status === 'success'
       ? ` ${paint('', `(${formatElapsed(outcome.durationMs)})`, colors, { dim: true })} ${paint(ACCENT, 'running', colors)}`
       : formatBlockFooter(outcome, colors)
-  const close = `${corner('└─')} ${mark}${paintTaskId(node, colors, { bold: true })} ${corner('──')}${tail}`
+  const close = `${corner('└─')} ${mark}${paintTaskId(node, colors, { bold: true })}${whereNote(outcome, colors)} ${corner('──')}${tail}`
   const violations = violationSection(outcome, colors)
   return violations.length === 0 ? close : `${violations.join('\n')}\n${close}`
 }

package/src/report/logger.ts

@@ -5,10 +5,13 @@ import {
   formatFrameOpen,
   formatKeptLines,
   formatPersistentTailBlock,
+  formatListHeader,
   formatTaskAbortedLine,
   formatTaskBlock,
   formatTaskExecutedLine,
   flakyNote,
+  pathNote,
+  whereNote,
   formatTaskHitLine,
   formatTaskSkippedLine,
   type OutputChunk,
@@ -346,7 +349,9 @@ export function defaultLogger(
   let forecastTimer: ReturnType<typeof setTimeout> | null = null
   let etaMs: 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
@@ -364,8 +369,8 @@ export function defaultLogger(
   // 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:
+  // 10 rows; excess running tasks queue for a freed slot, each shown
+  // in its own row after the slots. Focused flow keeps its lifecycle:
   // the region dies the moment a requested node starts streaming.
   let slots: (WorkerSlot | null)[] = []
   // Rows shown: the most workers busy at once so far. An idle row past it
@@ -472,6 +477,15 @@ export function defaultLogger(
     if (statusDead) return
     let force = forced
     const now = Date.now()
+    // 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
+      }
     // 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)
@@ -491,7 +505,7 @@ export function defaultLogger(
       const f = forecastFn(finished, running, now)
       etaMs = f.etaMs
       critical = f.critical
-      blocks = f.blocks
+      blockedCount = f.waiting
       expected = f.expected
       blocked = f.blocked
     }
@@ -509,6 +523,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 > 1) 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,6 +554,9 @@ export function defaultLogger(
               miss: succeeded + failed - noCache,
               noCache,
               left: total - done - stopped - notRun,
+              ...(running > 0 ? { running } : {}),
+              ...(scheduled > 0 ? { scheduled } : {}),
+              ...(blockedCount > 0 && !tail && !stopping ? { blocked: blockedCount } : {}),
               ...(etaMs !== undefined && !tail && !stopping ? { etaMs } : {}),
               buckets,
               spread:
@@ -549,14 +576,15 @@ export function defaultLogger(
       formatStatusRegion(
         {
           pinnedPersistent,
-          slots: slots.slice(0, shownSlots),
+          // Every running task has a row: one beyond the slots follows them (M, 2026-10-21).
+          slots: [...slots.slice(0, shownSlots), ...slotQueue],
           ...(held !== undefined ? { blocked: held } : {}),
-          overflow: slotQueue.length,
           ...(stopping ? { stopping } : {}),
           ...(shownSteps.length > 0 ? { steps: shownSteps } : {}),
           nowMs: Date.now(),
           summaryLines,
-          ...(blocks !== undefined ? { blocks } : {}),
+          ...(out.rows !== undefined && out.rows > 0 ? { rows: out.rows } : {}),
+          ...(runContext?.whereRunning !== undefined ? { where: runContext.whereRunning } : {}),
           ...(expected !== undefined ? { expected } : {}),
           ...(critical !== undefined ? { critical } : {}),
         },
@@ -644,6 +672,16 @@ 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 (M, 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 => {
@@ -684,6 +722,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 {
@@ -736,7 +776,7 @@ export function defaultLogger(
       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))
+        emitRow(formatStepLine(id, durationMs, ok, colors))
       refresh(true)
     },
     runStop() {
@@ -981,7 +1021,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
       }
@@ -1066,11 +1106,11 @@ export function defaultLogger(
         }
         case 'errors-only':
           if (outcome.status === 'skipped') {
-            emitLine(formatTaskSkippedLine(node, colors, outcome.blockedBy))
+            emitRow(formatTaskSkippedLine(node, colors, outcome.blockedBy))
             return
           }
           if (outcome.status !== 'failed') return
-          emitLine(failureRow(node, outcome))
+          emitRow(failureRow(node, outcome))
           deferredFailures.push(
             formatTaskBlock(
               node,
@@ -1090,7 +1130,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 +1143,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.blockedBy))
           }
           return
         case 'focused':
@@ -1114,7 +1154,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.blockedBy))
               return
             }
             if (streamsLive(node)) {
@@ -1135,7 +1175,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,
@@ -1167,9 +1207,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.blockedBy))
           } else if (outcome.status === 'failed') {
-            emitLine(failureRow(node, outcome))
+            emitRow(failureRow(node, outcome))
             deferredFailures.push(
               formatTaskBlock(
                 node,
@@ -1191,11 +1231,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.blockedBy))
             return
           }
           const block = formatTaskBlock(

package/src/report/status-line.ts

@@ -5,8 +5,15 @@
 // ordinary write erases the status display first, writes its content,
 // then redraws, so the display can never interleave with task output.
 
-import { dumbTerminal, paint, type ColorSupport } from '../util/index.js'
-import { formatTaskRow, paintIdParts, TIME_COL } from './framed-output.js'
+import { dumbTerminal, paint, ui, type ColorSupport } from '../util/index.js'
+import {
+  formatListHeader,
+  formatTaskRow,
+  paintIdParts,
+  pathNote,
+  placeNote,
+  TIME_COL,
+} from './framed-output.js'
 import type { BlockedTask } from './forecast.js'
 
 const NO_COLOR: ColorSupport = { enabled: false }
@@ -311,13 +318,17 @@ const IDLE = '#6b7280'
 export interface WorkerSlot {
   id: string
   startedMs: number
+  /** Its executor holds it for a machine to begin it (`TaskExecutor.running` is `null`). */
+  waiting?: boolean
 }
 
 export interface StatusRegionState {
-  /** A running task's unfinished dependents (`blocks 14` on its row); 0 says nothing. */
-  blocks?: ReadonlyMap<string, number>
+  /** The terminal's height: a region taller folds its rows, never its summary. */
+  rows?: number
   /** The running task at the head of the longest unfinished chain. */
   critical?: string
+  /** Where a running task runs, when not here (`TaskExecutor.running`); its row shows it. */
+  where?: (taskId: string) => string | null | undefined
   /** A running task's usual duration from history; its row shows it. */
   expected?: ReadonlyMap<string, number>
   /**
@@ -331,8 +342,6 @@ export interface StatusRegionState {
   slots: readonly (WorkerSlot | null)[]
   /** The blocked task an idle slot's row holds instead of `idle`, by the same index. */
   blocked?: readonly (BlockedTask | null)[]
-  /** Running tasks beyond the displayed slots. */
-  overflow: number
   /** The run was stopped: running rows say `aborting`, idle rows leave. */
   stopping?: boolean
   /**
@@ -451,9 +460,11 @@ export function formatStatusRegion(
   // place, dim, aligned under the status column: the blocked task the row
   // holds and what holds it back, else `idle`.
   // One task running has no path to compare against.
-  const busy = s.slots.filter((x) => x !== null).length
+  const busy = s.slots.filter((x) => x !== null && x.waiting !== true).length
   for (const [row, slot] of s.slots.entries()) {
-    if (slot === null && s.stopping === true) continue
+    // Placed by an executor (DTE), the list is what runs: blocked tasks are
+    // the tasks line's count alone (M, 2026-10-21).
+    if (slot === null && (s.stopping === true || s.where !== undefined)) continue
     if (slot === null) {
       const w = s.blocked?.[row]
       lines.push(
@@ -464,8 +475,6 @@ export function formatStatusRegion(
       )
       continue
     }
-    // What waits on it, after the id: the row to watch is the one the
-    // longest chain waits on, and the one the most tasks wait on.
     if (s.stopping === true) {
       lines.push(
         formatTaskRow(
@@ -481,10 +490,11 @@ export function formatStatusRegion(
       )
       continue
     }
-    const waiting = s.blocks?.get(slot.id) ?? 0
-    const notes: string[] = []
-    if (s.critical === slot.id && busy > 1) notes.push(paint(WARN, 'critical path', colors))
-    if (waiting > 0) notes.push(dim(`blocks ${waiting}`))
+    // Handed to an executor that has no machine on it yet: no row, only
+    // the tasks line's `scheduled` (M, 2026-10-21).
+    if (slot.waiting === true) continue
+    const at = s.where?.(slot.id)
+    const critical = s.critical === slot.id && busy > 1
     const usual = s.expected?.get(slot.id)
     lines.push(
       formatTaskRow(
@@ -496,12 +506,11 @@ export function formatStatusRegion(
         '',
         paintPinnedId(slot.id, colors),
         colors,
-      ) + (notes.length > 0 ? `  ${notes.join(dim(' \u00b7 '))}` : ''),
+      ) +
+        (critical ? pathNote(colors) : '') +
+        (at != null ? placeNote(at, colors) : ''),
     )
   }
-  if (s.overflow > 0) {
-    lines.push(dim(`\u2026 +${s.overflow} more running`))
-  }
   for (const step of s.steps ?? []) {
     lines.push(
       formatTaskRow(
@@ -516,6 +525,17 @@ export function formatStatusRegion(
       ),
     )
   }
+  if (lines.length > 1) lines.splice(1, 0, formatListHeader(s.where !== undefined, colors))
+  // A region taller than the terminal (a row spared) folds the rows past
+  // what fits into one line: the writer would cut the summary at its
+  // foot, and lines never printed cannot be scrolled to (M, 2026-10-21).
+  const room = s.rows === undefined ? Infinity : s.rows - 1 - s.summaryLines.length
+  if (lines.length > room && room >= 3) {
+    const kept = room - 1
+    const more = lines.length - kept
+    lines.length = kept
+    lines.push(`${' '.repeat(3 + TIME_COL + 1)}${dim(`+${more} more`)}`)
+  }
   // The live summary section — identical shape to the final printout,
   // so the region visually BECOMES the summary when the run ends.
   lines.push(...s.summaryLines)