@vzn/vx 0.0.646 → 0.0.649

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),
     )
   }