@vzn/vx 0.0.645 → 0.0.648

package/src/orchestrator/run-records.ts

@@ -7,7 +7,7 @@
 // tests/run-records.test.ts holds to this one.
 
 import type { InvocationRecord, RunRecord } from '../cache/index.js'
-import { isGroupTask, type TaskOutcome } from '../graph/index.js'
+import { isGroupTask, taskDefinition, type TaskOutcome } from '../graph/index.js'
 import { VERSION } from '../version.js'
 import type { CiContext, GitContext, HostContext } from './run-context.js'
 import { taskTelemetryOf, type TaskTelemetry } from './telemetry.js'
@@ -83,18 +83,15 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
     if (input.withTelemetry) telemetryTasks.push(taskTelemetryOf(o))
     const blockedBy = o.blockedBy ?? input.tainted?.get(o.node.id)
     const remoteError = remoteErrorOf(input.remoteTraffic, o.hash)
-    runs.push({
-      ...(o.hash !== undefined ? { hash: o.hash } : {}),
+    // Built field by field: a spread per optional field was ~2 µs of each
+    // of a 1,200-hit warm run's rows.
+    const hit = isCacheHit(o.status)
+    const r: RunRecord = {
       project: o.node.projectName,
       task: o.node.taskName,
       status: o.status,
       exitCode: o.exitCode,
       durationMs: o.durationMs,
-      // A run forwards its args to the tasks it was asked for, never to a
-      // dependency: the row says which ran with them.
-      ...(input.forwardArgs !== undefined && input.forwardArgs.length > 0 && o.node.requested
-        ? { forwardArgs: input.forwardArgs }
-        : {}),
       // Anchor to the REAL per-task wall-clock window: run-start wall time +
       // the task's ns offset (captured for hits and executed tasks alike).
       // The `end - duration` fallback applies to outcomes without an offset —
@@ -111,22 +108,37 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
           ? startedAtMs + Math.round(Number(o.wallclockEndNs) / 1e6)
           : endedAtMs,
       runId,
-      ...(o.cpuMs !== undefined ? { cpuMs: o.cpuMs } : {}),
-      ...(o.peakRssBytes !== undefined ? { peakRssBytes: o.peakRssBytes } : {}),
-      ...(o.wallclockStartNs !== undefined ? { wallclockStartNs: o.wallclockStartNs } : {}),
-      ...(o.wallclockEndNs !== undefined ? { wallclockEndNs: o.wallclockEndNs } : {}),
-      cacheHit: isCacheHit(o.status),
-      ...(isCacheHit(o.status) ? { restored: o.restored === true } : {}),
-      ...(o.attempts !== undefined ? { attempts: o.attempts } : {}),
+      cacheHit: hit,
       cached: o.node.config.cache !== undefined,
-      // A task that ran behind a failure names it too, so the flakiness
-      // projection counts its outcome on no key (failure-mode.ts).
-      ...(blockedBy !== undefined ? { blockedBy } : {}),
-      ...(o.timedOut === true ? { timedOut: true as const } : {}),
-      ...(o.sandboxViolations !== undefined ? { sandboxViolations: o.sandboxViolations } : {}),
-      ...(o.notReady !== undefined ? { notReady: o.notReady } : {}),
-      ...(remoteError !== undefined ? { remoteError } : {}),
-    })
+    }
+    if (o.hash !== undefined) r.hash = o.hash
+    // A run forwards its args to the tasks it was asked for, never to a
+    // dependency: the row says which ran with them.
+    if (input.forwardArgs !== undefined && input.forwardArgs.length > 0 && o.node.requested)
+      r.forwardArgs = input.forwardArgs
+    if (o.cpuMs !== undefined) r.cpuMs = o.cpuMs
+    if (o.peakRssBytes !== undefined) r.peakRssBytes = o.peakRssBytes
+    if (o.peakCores !== undefined) r.peakCores = o.peakCores
+    if (o.avgRssBytes !== undefined) r.avgRssBytes = o.avgRssBytes
+    if (o.where !== undefined) r.placement = o.where
+    if (o.whereCores !== undefined) r.placementCores = o.whereCores
+    if (o.whereMemoryBytes !== undefined) r.placementMemoryBytes = o.whereMemoryBytes
+    if (o.cpuShare !== undefined) r.cpuShare = o.cpuShare
+    if (o.wallclockStartNs !== undefined) r.wallclockStartNs = o.wallclockStartNs
+    if (o.wallclockEndNs !== undefined) r.wallclockEndNs = o.wallclockEndNs
+    if (hit) r.restored = o.restored === true
+    if (o.attempts !== undefined) r.attempts = o.attempts
+    // A task that ran behind a failure names it too, so the flakiness
+    // projection counts its outcome on no key (failure-mode.ts).
+    if (blockedBy !== undefined) r.blockedBy = blockedBy
+    if (o.timedOut === true) r.timedOut = true
+    if (o.sandboxViolations !== undefined) r.sandboxViolations = o.sandboxViolations
+    if (o.notReady !== undefined) r.notReady = o.notReady
+    if (remoteError !== undefined) r.remoteError = remoteError
+    if (o.keylessBy !== undefined) r.keylessBy = o.keylessBy
+    const def = taskDefinition(o.node)
+    if (def !== undefined) r.def = def
+    runs.push(r)
     if (o.status === 'failed') failedCount++
     if (o.status === 'cache-hit') hitLocalCount++
     if (o.status === 'cache-hit-remote') hitRemoteCount++

package/src/orchestrator/run-report.ts

@@ -1,9 +1,9 @@
 // The report every plugin's teardown reads, and the run's own bytes kept
-// in a remote that takes its writes (owner 2026-10-15): a failed task's
+// in a remote that takes its writes (2026-10-15): a failed task's
 // log and the files its outputs left (`cache.upload.failures`), and the
-// log of a task that saved no entry, on every run (M, 2026-10-16: "Always
+// log of a task that saved no entry, on every run (2026-10-16: "Always
 // keep"). Each task's bytes leave when it ends, off its path, like its
-// entry's upload (owner 2026-10-16); the run only waits for them where it
+// entry's upload (2026-10-16); the run only waits for them where it
 // waits for every upload, and the footer counts them as the task's remote
 // traffic.
 

package/src/orchestrator/run-steps.ts

@@ -1,14 +1,18 @@
-// The steps a run did not wait on (`vx:prefetch`), for `vx last` (M,
-// 2026-10-16): they never show in a run's output. One file per run that
-// had one, `<cacheDir>/steps/<runId>.json`, the newest 50 kept, as
+// What a run said that its rows do not hold, for `vx last`: the steps it
+// did not wait on (`vx:prefetch`, M 2026-10-16), which never show in a
+// run's output, and its warnings, which scroll past on a terminal and are
+// gone (an agent reading the run afterwards saw only the footer's count,
+// 2026-10-28). One file per run that had any, `<cacheDir>/steps/<runId>.json`
+// and `<cacheDir>/warnings/<runId>.json`, the newest 50 of each kept, as
 // run-failures.ts keeps failed output: files, not cache.db, so the index
 // layout stays as it was. A run with none writes nothing.
 
-import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { isFsRefusal } from '../util/index.js'
+import { trimKept } from './run-failures.js'
 
-/** Runs whose background steps are kept; run ids are UUIDv7, so names sort by age. */
+/** Runs whose steps (or warnings) are kept; run ids are UUIDv7, so names sort by age. */
 const KEPT = 50
 
 /** One of vx's own steps that ran beside the tasks. */
@@ -18,40 +22,72 @@ export interface RunStep {
   ok: boolean
 }
 
-const dirOf = (cacheDir: string): string => path.join(cacheDir, 'steps')
+type Kept = 'steps' | 'warnings'
 
-/** Keep `steps` for `runId`; a refused write costs only them. */
-export function writeRunSteps(
+function keep(
   cacheDir: string,
+  kind: Kept,
   runId: string,
-  steps: readonly RunStep[],
+  value: readonly unknown[],
   warn: (message: string) => void,
 ): void {
-  if (steps.length === 0) return
+  if (value.length === 0) return
   try {
-    const dir = dirOf(cacheDir)
+    const dir = path.join(cacheDir, kind)
     mkdirSync(dir, { recursive: true })
     const file = path.join(dir, `${runId}.json`)
     const tmp = `${file}.${process.pid}.tmp`
-    writeFileSync(tmp, JSON.stringify(steps))
+    writeFileSync(tmp, JSON.stringify(value))
     renameSync(tmp, file)
-    const names = readdirSync(dir)
-      .filter((n) => n.endsWith('.json'))
-      .sort()
-    for (const n of names.slice(0, -KEPT)) rmSync(path.join(dir, n), { force: true })
+    trimKept(dir, KEPT)
   } catch (err) {
     if (!isFsRefusal(err)) throw err
-    warn(`[vx] background steps not kept: ${err.message} — the verdict above stands`)
+    warn(
+      `[vx] ${kind === 'steps' ? 'background steps' : 'warnings'} not kept: ${err.message} — the verdict above stands`,
+    )
   }
 }
 
-/** The background steps `runId` kept; none when it had none or they are gone. */
-export function runSteps(cacheDir: string, runId: string): RunStep[] {
+function kept<T>(cacheDir: string, kind: Kept, runId: string): T[] {
   try {
-    return JSON.parse(
-      readFileSync(path.join(dirOf(cacheDir), `${runId}.json`), 'utf8'),
-    ) as RunStep[]
+    return JSON.parse(readFileSync(path.join(cacheDir, kind, `${runId}.json`), 'utf8')) as T[]
   } catch {
     return []
   }
 }
+
+/** Keep `steps` for `runId`; a refused write costs only them. */
+export function writeRunSteps(
+  cacheDir: string,
+  runId: string,
+  steps: readonly RunStep[],
+  warn: (message: string) => void,
+): void {
+  keep(cacheDir, 'steps', runId, steps, warn)
+}
+
+/** The background steps `runId` kept; none when it had none or they are gone. */
+export function runSteps(cacheDir: string, runId: string): RunStep[] {
+  return kept<RunStep>(cacheDir, 'steps', runId)
+}
+
+/** Keep the run's warnings as plain text, colour stripped; a refused write costs only them. */
+export function writeRunWarnings(
+  cacheDir: string,
+  runId: string,
+  warnings: readonly string[],
+  warn: (message: string) => void,
+): void {
+  keep(
+    cacheDir,
+    'warnings',
+    runId,
+    warnings.map((w) => Bun.stripANSI(w)),
+    warn,
+  )
+}
+
+/** The warnings `runId` said; none when it said none or they are gone. */
+export function runWarnings(cacheDir: string, runId: string): string[] {
+  return kept<string>(cacheDir, 'warnings', runId)
+}

package/src/orchestrator/run-stop.ts

@@ -25,6 +25,14 @@ import {
 
 type Child = ReturnType<typeof Bun.spawn>
 
+/**
+ * The abort reason that stops a run's own work and spares the servers it
+ * was handed (`RunOptions.keep`), which it hands back. `vx watch` stops a
+ * cycle waiting on a server that never becomes ready (WD-15); any other
+ * stop took the unchanged servers down with it, and they restarted.
+ */
+export const CYCLE_INTERRUPT = 'vx:cycle-interrupt'
+
 export interface RunStop {
   readonly signal: AbortSignal
   readonly liveChildren: Set<Child>
@@ -33,8 +41,10 @@ export interface RunStop {
    * The process signal that stopped the run. A run a process signal
    * stopped records no history: until item 849 the handler exited before
    * any outcome landed, and a Ctrl-C'd run then read in `vx last` as
-   * FAILED with 0 tasks (item 854). An embedder's abort is its own call
-   * and keeps its record.
+   * FAILED with 0 tasks (item 854). So does an embedder's abort whose
+   * reason names one (`'SIGINT'`, `'SIGTERM'`, `'SIGHUP'`): the signal the
+   * embedder received, as the watch loop relays a Ctrl-C to its cycle. Any
+   * other abort is the embedder's own call and keeps its record.
    */
   readonly stoppedBy: StopSignal | undefined
   /**
@@ -71,6 +81,8 @@ export function runStop(args: {
   teardowns: number
   /** Called first when the run is stopped. */
   onStop: () => void
+  /** A server the run was handed: a `CYCLE_INTERRUPT` leaves it running. */
+  handed: (child: Child) => boolean
 }): RunStop {
   const { log, external } = args
   const liveChildren = new Set<Child>()
@@ -90,10 +102,14 @@ export function runStop(args: {
     }
   })()
   const controller = new AbortController()
-  const forwardAbort = (): void => controller.abort(external?.reason)
+  let stoppedBy: StopSignal | undefined
+  const forwardAbort = (): void => {
+    const reason: unknown = external?.reason
+    if (reason === 'SIGINT' || reason === 'SIGTERM' || reason === 'SIGHUP') stoppedBy = reason
+    controller.abort(reason)
+  }
   if (external?.aborted === true) forwardAbort()
   else external?.addEventListener('abort', forwardAbort, { once: true })
-  let stoppedBy: StopSignal | undefined
   let left = (): void => {}
   const runLeft = new Promise<void>((resolve) => {
     left = resolve
@@ -120,8 +136,9 @@ export function runStop(args: {
   const onAbort = (): void => {
     args.onStop()
     endedBeforeStop = new Set([...persistentRegistry.values()].filter(hasEnded))
+    const spare = controller.signal.reason === CYCLE_INTERRUPT ? args.handed : () => false
     aborting = terminateChildren(
-      () => [...liveChildren, ...persistentRegistry.values()],
+      () => [...liveChildren, ...persistentRegistry.values()].filter((c) => !spare(c)),
       forwardedSignal(controller.signal.reason),
     )
   }