@vzn/vx 0.0.640 → 0.0.642

package/src/orchestrator/signals.ts

@@ -126,9 +126,11 @@ export function forwardSignals(args: {
   const everyChild = (): Child[] => [...args.liveChildren, ...args.persistentRegistry.values()]
   const exit = (signal: StopSignal): never => {
     // The run's own end already flushed the log; a second signal cut it
-    // short, so the failure frames it holds print now (idempotent).
+    // short, so the failure frames it holds print now (idempotent), and
+    // the live region goes so a terminal keeps no frozen one.
     try {
       args.log.runEnd?.()
+      args.log.runDone?.()
     } catch {
       // teardown must not throw on the way out
     }
@@ -158,15 +160,10 @@ export function forwardSignals(args: {
     if (stopping !== undefined) exit(stopping)
     stopping = signal
     claimExitForSignal()
-    // Clear the live worker/status region BEFORE exiting so a TTY isn't
-    // left with a frozen region in the scrollback. Only the region: the
-    // tasks this stop aborts still list as rows, above the failure frames
-    // the run's own end prints.
-    try {
-      args.log.runDone?.()
-    } catch {
-      // teardown must not throw on the way out
-    }
+    // The live region stays: the stop marks its rows `stopping` (run.ts's
+    // onStop), and the run's own end replaces it with the footer. Cleared
+    // at once, it left a blank screen for as long as the stop took (M,
+    // 2026-10-17).
     args.stop(signal)
     void settleWithin(args.done, args.boundMs)
       // The run's output may still be in the pipe: `process.exit` drops

package/src/orchestrator/stable-keys.ts

@@ -145,6 +145,11 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
     }
   }
   const wsOutputUpstreamById = new Map<string, boolean>()
+  const upstreamByDeps = new Map<
+    string,
+    { outputProjects: ProjectSet; wide: ProjectSet | undefined; wsOutputUpstream: boolean }
+  >()
+  const noProjects = projects.empty()
   const stableKeys: StableKey[] = []
   // Workspace-relative project dirs, for the reach test of a
   // `workspaceFiles` reader against its upstream producers.
@@ -160,39 +165,59 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
     const upstream = synthUpstream(node, args.nodes, keyById)
 
     // Fold every dep's accumulated producers + the dep's own declared
-    // outputs into this node's transitive-upstream producer sets.
-    const outputProjects = projects.empty()
-    let wide: ProjectSet | undefined
+    // outputs into this node's transitive-upstream producer sets. They
+    // depend on the deps alone, and at 5,000 projects a `^build` reader
+    // shares its list with its project's group: 61,600 unions of 157-word
+    // sets were 52 ms of a warm run, half of them repeats.
+    const depsKey = node.deps.length === 1 ? node.deps[0]! : node.deps.join('\0')
+    let up = upstreamByDeps.get(depsKey)
+    if (up === undefined) {
+      const outputs = new Union(projects)
+      const wideUnion = new Union(projects)
+      let wsOutputUpstream = false
+      for (const dep of node.deps) {
+        const depNode = args.nodes.get(dep)
+        if (!depNode) continue
+        const upstreamOfDep = outputProjectsById.get(dep)
+        if (upstreamOfDep !== undefined) outputs.addAll(upstreamOfDep)
+        const wideOfDep = wideById.get(dep)
+        if (wideOfDep !== undefined) wideUnion.addAll(wideOfDep)
+        if (wsOutputUpstreamById.get(dep) === true) wsOutputUpstream = true
+        const depOut = depNode.config.cache?.outputs
+        if ((depOut?.files?.length ?? 0) > 0) outputs.add(depNode.projectName)
+        if ((depOut?.workspaceFiles?.length ?? 0) > 0) wsOutputUpstream = true
+        // An uncached producer declares no outputs, yet a same-project reader
+        // after it (`tasks: []` decouples the key, not the order) read the
+        // bytes it wrote: its key taken up front was the pre-producer one, and
+        // the fourth run of seeds A,B,B,A replayed B over A (turborepo#13788).
+        const reach = undeclaredWriteReach(depNode, args.workspaceRoot)
+        if (reach === 'project') {
+          outputs.add(depNode.projectName)
+          wideUnion.add(depNode.projectName)
+        } else if (reach === 'workspace') wsOutputUpstream = true
+        if (
+          depNode.config.cache === undefined &&
+          mayWriteFingerprint(depNode, args.workspaceRoot, args.claimedFiles)
+        )
+          wsOutputUpstream = true
+      }
+      up = {
+        outputProjects: outputs.result() ?? noProjects,
+        wide: wideUnion.result(),
+        wsOutputUpstream,
+      }
+      upstreamByDeps.set(depsKey, up)
+    }
+    const { outputProjects, wide, wsOutputUpstream } = up
     let rewriters: ProjectSet | undefined
     let unfolded: ProjectSet | undefined
     let folds: ((dep: string) => boolean) | undefined
     let wsRewriter = false
     let wsUnfoldedHere = false
-    let wsOutputUpstream = false
-    for (const dep of node.deps) {
+    for (const dep of anyUnfolded ? node.deps : []) {
       const depNode = args.nodes.get(dep)
       if (!depNode) continue
-      const upstreamOfDep = outputProjectsById.get(dep)
-      if (upstreamOfDep !== undefined) outputProjects.addAll(upstreamOfDep)
-      const wideOfDep = wideById.get(dep)
-      if (wideOfDep !== undefined) (wide ??= projects.empty()).addAll(wideOfDep)
-      if (wsOutputUpstreamById.get(dep) === true) wsOutputUpstream = true
-      const depOut = depNode.config.cache?.outputs
-      if ((depOut?.files?.length ?? 0) > 0) outputProjects.add(depNode.projectName)
-      if ((depOut?.workspaceFiles?.length ?? 0) > 0) wsOutputUpstream = true
-      // An uncached producer declares no outputs, yet a same-project reader
-      // after it (`tasks: []` decouples the key, not the order) read the
-      // bytes it wrote: its key taken up front was the pre-producer one, and
-      // the fourth run of seeds A,B,B,A replayed B over A (turborepo#13788).
-      const reach = undeclaredWriteReach(depNode, args.workspaceRoot)
-      if (reach === 'project') {
-        outputProjects.add(depNode.projectName)
-        ;(wide ??= projects.empty()).add(depNode.projectName)
-      } else if (reach === 'workspace') wsOutputUpstream = true
       const cached = depNode.config.cache !== undefined
-      if (!cached && mayWriteFingerprint(depNode, args.workspaceRoot, args.claimedFiles))
-        wsOutputUpstream = true
-      if (!anyUnfolded) continue
       // The cached twin: a formatter rewriting its own input ahead of a
       // reader that folds no key of it replayed seed B's build under seed A
       // on the fourth run, the same way (item 750).
@@ -732,6 +757,10 @@ class ProjectSet implements ProjectNames {
     for (let w = 0; w < this.bits.length; w++) this.bits[w]! |= other.bits[w]!
   }
 
+  copy(): ProjectSet {
+    return new ProjectSet(this.index, this.bits.slice())
+  }
+
   or(other: ProjectSet): ProjectSet {
     const bits = this.bits.slice()
     for (let w = 0; w < bits.length; w++) bits[w]! |= other.bits[w]!
@@ -762,6 +791,35 @@ class ProjectSet implements ProjectNames {
   }
 }
 
+/** A union that shares its first set until another one would change it. */
+class Union {
+  private set: ProjectSet | undefined
+  private owned = false
+
+  constructor(private readonly index: ProjectIndex) {}
+
+  addAll(other: ProjectSet): void {
+    if (this.set === undefined) this.set = other
+    else if (this.set !== other) this.own().addAll(other)
+  }
+
+  add(name: string): void {
+    if (this.set?.has(name) !== true) this.own().add(name)
+  }
+
+  result(): ProjectSet | undefined {
+    return this.set
+  }
+
+  private own(): ProjectSet {
+    if (!this.owned) {
+      this.set = this.set === undefined ? this.index.empty() : this.set.copy()
+      this.owned = true
+    }
+    return this.set!
+  }
+}
+
 function topoOrder(nodes: ReadonlyMap<string, TaskNode>): string[] {
   const indegree = new Map<string, number>()
   const dependents = new Map<string, string[]>()

package/src/orchestrator/task-hash.ts

@@ -1,17 +1,20 @@
 import { lstatSync } from 'node:fs'
 import path from 'node:path'
 import type { TaskConfig } from '../config.js'
-import type { ProjectFilesCache, WorkspaceFilesCache } from '../cache/index.js'
+import type { FoldMemo, ProjectFilesCache, WorkspaceFilesCache } from '../cache/index.js'
 import {
   ABSENT_INPUT,
   absentOr,
   addedInput,
+  filesToken,
+  foldHead,
   type InputListing,
   type CacheKeyInput,
   type CacheLayer,
   FILE_HASH_RACY_MS,
   racyWindowMs,
   resolveInputs,
+  type ResolveInputsArgs,
   type GitFilesCache,
   type TaskInputComponent,
   WORKSPACE_OUTPUT_PREFIX,
@@ -41,15 +44,18 @@ export interface HashCache {
   workspaceRuntime: Map<string, Promise<string>>
   workspaceFiles: WorkspaceFilesCache
   projectFiles: ProjectFilesCache
+  /** Each task's last key by its probe, across runs (the local cache's `FoldMemo`). */
+  folds?: FoldMemo | undefined
 }
 
-export function createHashCache(): HashCache {
+export function createHashCache(folds?: FoldMemo): HashCache {
   return {
     taskConfig: new WeakMap(),
     runtime: new Map(),
     workspaceRuntime: new Map(),
     workspaceFiles: new Map(),
     projectFiles: new Map(),
+    folds,
   }
 }
 
@@ -93,12 +99,31 @@ export async function computeTaskHash(args: ComputeHashArgs): Promise<string> {
   if (isKeyless(args.node.config)) return keylessHash(args.node.id)
   const end = span('task hash')
   try {
-    return await args.cache.key((await resolveKeyInput(args)).input)
+    const folds = args.captureInto === undefined ? args.hashCache?.folds : undefined
+    const token = folds === undefined ? undefined : filesToken(inputsArgs(args))
+    if (folds === undefined || token === undefined) {
+      return await args.cache.key((await resolveKeyInput(args)).input)
+    }
+    // The files fold last, so a fold up to them seeded into their token
+    // names the key the whole fold would: the files go unresolved.
+    const head = foldHead((await resolveKeyInput(args, true)).input)
+    const probe = xxh3hex(`${FOLD_MEMO_VERSION}\0${token}`, head)
+    const known = folds.get(args.node.id, probe)
+    if (known !== undefined) return known
+    const key = await args.cache.key((await resolveKeyInput(args)).input)
+    folds.set(args.node.id, probe, key)
+    return key
   } finally {
     end()
   }
 }
 
+/**
+ * Moves every remembered fold: bump it when what a token stands for
+ * changes, as when `resolveFiles` picks other files from the same records.
+ */
+const FOLD_MEMO_VERSION = 'fold-memo-v1'
+
 /**
  * A task that runs a command and declares no `inputs`: nothing says what
  * it read, so no key can stand for its outputs, and a key that folds it
@@ -268,19 +293,16 @@ export async function movedInput(
   return undefined
 }
 
-async function resolveKeyInput(
-  args: ComputeHashArgs,
-): Promise<{ input: CacheKeyInput; listings: InputListing[] }> {
+/** What `resolveInputs` is asked for a task's key. */
+function inputsArgs(args: ComputeHashArgs): ResolveInputsArgs {
   const cfg = args.node.config
   const cacheCfg = cfg.cache
-  const outputs = cacheCfg?.outputs.files ?? []
-
-  const resolved = await resolveInputs({
+  return {
     projectDir: args.node.projectDir,
     workspaceRoot: args.workspaceRoot,
     envSource: process.env,
     inputs: cfg.inputs,
-    ownOutputs: outputs,
+    ownOutputs: cacheCfg?.outputs.files ?? [],
     ownWorkspaceOutputs: cacheCfg?.outputs.workspaceFiles ?? [],
     nestedProjectDirs: args.nestedProjectDirs,
     ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
@@ -293,6 +315,17 @@ async function resolveKeyInput(
           projectFilesCache: args.hashCache.projectFiles,
         }
       : {}),
+  }
+}
+
+async function resolveKeyInput(
+  args: ComputeHashArgs,
+  skipFiles = false,
+): Promise<{ input: CacheKeyInput; listings: InputListing[] }> {
+  const cfg = args.node.config
+  const resolved = await resolveInputs({
+    ...inputsArgs(args),
+    ...(skipFiles ? { skipFiles } : {}),
   }).catch((err: unknown) => {
     // A failed probe's message quotes its command and output, and the probe
     // runs in vx's own environment: `echo $NPM_TOKEN` printed the token in
@@ -327,8 +360,9 @@ async function resolveKeyInput(
   // in-process blob-OID computation. Tasks declaring workspaceFiles
   // also merge the workspace-wide partition's OIDs (keyed by abs
   // path, so the two maps agree wherever they overlap).
-  let fileHashes = args.gitFilesCache?.oidsFor(args.node.projectDir)
-  if ((cfg.inputs?.workspaceFiles?.length ?? 0) > 0) {
+  // A fold that stops short of the files reads no OID: asking built the map.
+  let fileHashes = skipFiles ? undefined : args.gitFilesCache?.oidsFor(args.node.projectDir)
+  if (!skipFiles && (cfg.inputs?.workspaceFiles?.length ?? 0) > 0) {
     const wsOids = args.gitFilesCache?.oidsFor(args.workspaceRoot)
     if (wsOids !== undefined && wsOids !== fileHashes) {
       fileHashes = fileHashes === undefined ? wsOids : new Map([...wsOids, ...fileHashes])

package/src/report/events.ts

@@ -55,6 +55,7 @@ export type RunEvent =
   | { kind: 'step:start'; id: string }
   | { kind: 'step:end'; id: string; durationMs: number; ok: boolean }
   | { kind: 'run:end' }
+  | { kind: 'run:stop' }
   | { kind: 'run:done' }
 
 export type RunEventSubscriber = (event: RunEvent) => void
@@ -117,6 +118,7 @@ export function busLogger(bus: EventBus): Logger {
   // run() reaches runEnd on its success path, in its finally and from a
   // signal; a plugin's onRunEnd hears the first only.
   let ended = false
+  let stopped = false
   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).
@@ -136,6 +138,11 @@ export function busLogger(bus: EventBus): Logger {
     },
     stepStart: (id) => bus.emit({ kind: 'step:start', id }),
     stepEnd: (id, info) => bus.emit({ kind: 'step:end', id, ...info }),
+    runStop: () => {
+      if (stopped) return
+      stopped = true
+      bus.emit({ kind: 'run:stop' })
+    },
     runDone: () => {
       if (done) return
       done = true
@@ -182,6 +189,9 @@ export function terminalSubscriber(sink: Logger): RunEventSubscriber {
       case 'run:end':
         sink.runEnd?.()
         return
+      case 'run:stop':
+        sink.runStop?.()
+        return
       case 'run:done':
         sink.runDone?.()
         return
@@ -467,6 +477,7 @@ export type WireEvent =
   | { kind: 'step:start'; id: string }
   | { kind: 'step:end'; id: string; durationMs: number; ok: boolean }
   | { kind: 'run:end' }
+  | { kind: 'run:stop' }
   | { kind: 'run:done' }
 
 /** Map an in-process event to its serializable wire form. */
@@ -489,6 +500,7 @@ export function toWireEvent(event: RunEvent): WireEvent {
     case 'step:start':
     case 'step:end':
     case 'run:end':
+    case 'run:stop':
     case 'run:done':
       return event
   }

package/src/report/framed-output.ts

@@ -357,7 +357,8 @@ export function formatTaskRow(
   colors: ColorSupport = NO_COLOR,
 ): string {
   const st = cell(status, statusColor, STATUS_COL, colors)
-  const ca = cell(cache, cacheColor, CACHE_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}`
 }
 

package/src/report/logger.ts

@@ -92,6 +92,8 @@ export interface Logger {
    */
   stepStart?(id: string): void
   stepEnd?(id: string, info: { durationMs: number; ok: boolean }): void
+  /** The run was stopped (a signal, an embedder's abort); its tasks are going down. Idempotent. */
+  runStop?(): void
   /** The run's work is done; the footer follows. Idempotent. */
   runDone?(): void
 }
@@ -116,11 +118,15 @@ export interface DefaultLogger extends Logger {
    */
   readonly showsSteps: boolean
   /**
-   * Hand the live region a way to predict the run's end. Called once at
-   * run start; `load` runs only if the region is still live a second in,
-   * so a run that ends sooner never reads history for it.
+   * Hand the live region the run's forecast. Called once at run start:
+   * `graph` (the graph alone: what is blocked, and by what) is built the
+   * first time a worker row is free; `load` adds history's timings, and
+   * runs only if the region is still live a second in, so a run that ends
+   * sooner never reads history for it.
    */
-  forecast(load: () => Promise<Forecast>): void
+  forecast(graph: () => Forecast, load: () => Promise<Forecast>): void
+  /** Draw no live region until the returned release: a prompt waits on the terminal. */
+  holdStatus(): () => void
 }
 
 /**
@@ -336,6 +342,7 @@ export function defaultLogger(
   // set is kept only where a region can show the answer.
   const finished = new Set<string>()
   let forecastFn: Forecast | undefined
+  let graphForecast: (() => Forecast) | undefined
   let forecastTimer: ReturnType<typeof setTimeout> | null = null
   let etaMs: number | undefined
   let critical: string | undefined
@@ -381,6 +388,12 @@ export function defaultLogger(
   // 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).
   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).
+  let stopping = false
+  // Counted live once the run is stopping, as the footer counts them.
+  let stopped = 0
+  let notRun = 0
   // No footer before the run starts: vx's opening steps show alone.
   let started = false
   // vx's own steps running now, by id: a row once one passes STEP_SHOWN_MS.
@@ -456,11 +469,22 @@ export function defaultLogger(
   const printsKept = (tail: { outcome?: TaskOutcome }): boolean =>
     flushedPersistent && tail.outcome !== undefined && view.mode !== 'errors-only'
 
-  const refresh = (force: boolean): void => {
+  const refresh = (forced: boolean): void => {
     if (statusDead) return
+    let force = forced
     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
+        }
     // Twice a second at most: one pass over the unfinished graph.
-    if (forecastFn !== undefined && !tail && (force || now - etaAtMs >= 500)) {
+    if (forecastFn !== undefined && !tail && !stopping && (force || now - etaAtMs >= 500)) {
       etaAtMs = now
       const running = new Map<string, number>()
       for (const s of slots) if (s !== null) running.set(s.id, s.startedMs)
@@ -496,7 +520,9 @@ export function defaultLogger(
               failed,
               successful: succeeded + upToDate + restoredLocal + restoredRemote,
               skipped: skippedCount,
-              total,
+              total: total - stopped - notRun,
+              ...(stopped > 0 ? { aborted: stopped } : {}),
+              ...(notRun > 0 ? { notRun } : {}),
               upToDate,
               restoredLocal,
               restoredRemote,
@@ -505,8 +531,8 @@ export function defaultLogger(
               miss: succeeded + failed - noCache,
               noCache,
               savedMs,
-              left: total - done,
-              ...(etaMs !== undefined && !tail ? { etaMs } : {}),
+              left: total - done - stopped - notRun,
+              ...(etaMs !== undefined && !tail && !stopping ? { etaMs } : {}),
               buckets,
               spread:
                 spreadCount > 0
@@ -517,7 +543,7 @@ export function defaultLogger(
             colors,
             runContext,
           )
-    const held = blocked === undefined ? undefined : holdRows(blocked)
+    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 })
@@ -528,6 +554,7 @@ export function defaultLogger(
           slots: slots.slice(0, shownSlots),
           ...(held !== undefined ? { blocked: held } : {}),
           overflow: slotQueue.length,
+          ...(stopping ? { stopping } : {}),
           ...(shownSteps.length > 0 ? { steps: shownSteps } : {}),
           nowMs: Date.now(),
           summaryLines,
@@ -714,6 +741,13 @@ export function defaultLogger(
         emitLine(formatStepLine(id, durationMs, ok, colors))
       refresh(true)
     },
+    runStop() {
+      if (stopping) return
+      stopping = true
+      blocked = undefined
+      heldRows.length = 0
+      refresh(true)
+    },
     runDone() {
       tail = false
       killStatus()
@@ -755,8 +789,10 @@ export function defaultLogger(
       } else slotQueue.push(slot)
       refresh(true)
     },
-    forecast(load) {
+    holdStatus: () => writer.hold(),
+    forecast(graph, load) {
       if (statusDead || forecastTimer !== null) return
+      graphForecast = graph
       forecastTimer = setTimeout(() => {
         forecastTimer = null
         if (statusDead) return
@@ -898,9 +934,13 @@ export function defaultLogger(
       // a ready one starts a fresh post-ready tail below.
       persistentTails.delete(node.id)
       // An aborted task (killed by a shutdown signal, or reached by the stop
-      // before it ran) frees its worker slot but is never counted live: the
-      // run is tearing down and it has no honest outcome.
+      // before it ran) frees its worker slot and counts as the footer will
+      // count it: `aborted` or `not run`, beside no total.
       if (outcome.status === 'aborted') {
+        if (!isGroupTask(node)) {
+          if (neverStarted(outcome)) notRun++
+          else stopped++
+        }
         const si = slots.findIndex((s) => s !== null && s.id === node.id)
         if (si >= 0) slots[si] = slotQueue.shift() ?? null
         else {
@@ -973,8 +1013,11 @@ export function defaultLogger(
           const qi = slotQueue.findIndex((s) => s.id === node.id)
           if (qi >= 0) slotQueue.splice(qi, 1)
         }
-        const bucket = outcome.hash === undefined ? undefined : cacheBucketOf(outcome)
-        if (bucket !== undefined) buckets.set(outcome.hash!, bucket)
+        const bucket = cacheBucketOf(outcome)
+        if (bucket !== undefined) {
+          if (outcome.hash !== undefined) buckets.set(outcome.hash, bucket)
+          buckets.set(node.id, bucket)
+        }
         switch (outcome.status) {
           case 'success':
             succeeded++

package/src/report/status-line.ts

@@ -56,6 +56,11 @@ export interface OutputWriter {
   settle(): void
   /** Permanently remove the status display; later set* is a no-op. */
   clearStatus(): void
+  /**
+   * Erase the status display and draw none until the returned release:
+   * a prompt on the terminal (a secret's) waits for its answer there.
+   */
+  hold(): () => void
 }
 
 export interface OutputWriterOptions {
@@ -108,6 +113,7 @@ export function createOutputWriter(
   // `regionRows`.
   let shownRows = 0
   let dead = false
+  let holds = 0
   let lastDraw = -Infinity
   // Trailing draw scheduled when a forced set lands inside the floor.
   let trailing: ReturnType<typeof setTimeout> | null = null
@@ -196,7 +202,7 @@ export function createOutputWriter(
   const set = (lines: readonly string[], o: { force?: boolean }): void => {
     if (!enabled || dead) return
     current = lines
-    if (!atLineStart) return
+    if (!atLineStart || holds > 0) return
     const since = now() - lastDraw
     if (o.force) {
       if (since >= forceFloorMs) {
@@ -209,7 +215,7 @@ export function createOutputWriter(
       if (trailing === null) {
         trailing = setTimeout(() => {
           trailing = null
-          if (dead || current === null || !atLineStart) return
+          if (dead || current === null || !atLineStart || holds > 0) return
           draw()
         }, forceFloorMs - since)
         trailing.unref?.()
@@ -241,7 +247,7 @@ export function createOutputWriter(
       }
       stream.write(chunk)
       if (chunk.length > 0) atLineStart = chunk.endsWith('\n')
-      if (!dead && current !== null && atLineStart) draw()
+      if (!dead && current !== null && atLineStart && holds === 0) draw()
     },
     writeTo(target, chunk) {
       if (target === stream) return this.write(chunk)
@@ -257,7 +263,7 @@ export function createOutputWriter(
         shownRows = 0
       }
       target.write(chunk)
-      if (!dead && current !== null && atLineStart) draw()
+      if (!dead && current !== null && atLineStart && holds === 0) draw()
     },
     setStatus(line, o = {}) {
       set([line], o)
@@ -280,6 +286,23 @@ export function createOutputWriter(
         shownRows = 0
       }
     },
+    hold() {
+      if (!enabled || dead) return () => undefined
+      holds++
+      cancelTrailing()
+      if (shown) {
+        stream.write(eraseSeq())
+        shown = false
+        shownRows = 0
+      }
+      let released = false
+      return () => {
+        if (released) return
+        released = true
+        holds--
+        if (holds === 0 && !dead && current !== null && atLineStart) draw()
+      }
+    },
   }
 }
 
@@ -310,6 +333,8 @@ export interface StatusRegionState {
   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
   /**
    * vx's own steps still running, shown below the worker rows: no worker
    * slot or `--concurrency` bounds them (M, 2026-10-15).
@@ -428,6 +453,7 @@ export function formatStatusRegion(
   // One task running has no path to compare against.
   const busy = s.slots.filter((x) => x !== null).length
   for (const [row, slot] of s.slots.entries()) {
+    if (slot === null && s.stopping === true) continue
     if (slot === null) {
       const w = s.blocked?.[row]
       lines.push(
@@ -440,6 +466,21 @@ export function formatStatusRegion(
     }
     // 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(
+          ' ',
+          Math.max(0, s.nowMs - slot.startedMs),
+          'aborting',
+          WARN,
+          '',
+          '',
+          paintPinnedId(slot.id, colors),
+          colors,
+        ),
+      )
+      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))