@vzn/vx 0.0.159 → 0.0.160

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.159",
+  "version": "0.0.160",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.159",
-    "@vzn/vx-linux-arm64": "0.0.159",
-    "@vzn/vx-darwin-x64": "0.0.159",
-    "@vzn/vx-darwin-arm64": "0.0.159"
+    "@vzn/vx-linux-x64": "0.0.160",
+    "@vzn/vx-linux-arm64": "0.0.160",
+    "@vzn/vx-darwin-x64": "0.0.160",
+    "@vzn/vx-darwin-arm64": "0.0.160"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/exec/local-executor.ts

@@ -46,6 +46,7 @@ export function localExecutor(): TaskExecutor {
         reportWithin: req.sandbox.reportWithin,
         reportLinked: req.sandbox.reportLinked,
         config: req.sandbox.config,
+        ...(req.signal !== undefined ? { signal: req.signal } : {}),
       })
     },
   }

package/src/exec/sandbox-runtime.ts

@@ -619,6 +619,8 @@ export interface SandboxedRunArgs {
   onStderr?: (chunk: string) => void
   /** See `RunOptions.liveChildren` — same contract for sandboxed spawns. */
   liveChildren?: Set<ReturnType<typeof Bun.spawn>>
+  /** `ExecuteRequest.signal`: once aborted, the tracer retry spawns nothing. */
+  signal?: AbortSignal
   /** See `RunOptions.timeoutMs` — SIGTERM the child after this many ms. */
   timeoutMs?: number
   /** See `CaptureConfig` — which streams are retained on the result. */
@@ -1226,12 +1228,14 @@ const TRACER_RETRY_LINE =
  * strace runs detached (`-DD`), and a tracer that dies leaves the command
  * running untraced — but the trace then stops short, and a denial after it
  * goes unreported. So an attempt whose stderr carries strace's own word is
- * run once more, whatever its exit: the sandbox kept its writes to what it
+ * run once more, whatever its exit, unless the run is stopping: the sandbox kept its writes to what it
  * declared, so a second run redoes, not doubles, it.
  */
 export async function runSandboxed(args: SandboxedRunArgs): Promise<SandboxedRunResult> {
   const { tracerFailed, ...first } = await runSandboxedOnce(args)
-  if (!tracerFailed) return first
+  // A stopping run has killed the children it holds; a retry would be one
+  // spawned after that kill.
+  if (!tracerFailed || args.signal?.aborted === true) return first
   args.onStderr?.(TRACER_RETRY_LINE)
   const { tracerFailed: _again, ...second } = await runSandboxedOnce(args)
   return {

package/src/orchestrator/history.ts

@@ -15,9 +15,16 @@ import type { Database } from 'bun:sqlite'
 import { EXECUTED_RUNS_SQL } from '../cache/index.js'
 import { failureModeOf, mixedOutcomeKeysSql } from './failure-mode.js'
 import type { FailureMode } from './failure-mode.js'
+import { isPassStatus, TASK_STATUSES } from './telemetry.js'
 
 const DEFAULT_RECENT = 50
 
+// A hit is recorded as `cache-hit` / `cache-hit-remote` and replays a
+// success; the list is derived so a new status cannot miss it.
+const PASS_STATUSES = `(${TASK_STATUSES.filter(isPassStatus)
+  .map((s) => `'${s}'`)
+  .join(', ')})`
+
 /** Per (project#task) — last RECENT runs collapsed into a summary. */
 export interface TaskHistory {
   /** Total runs in the recent window. */
@@ -108,7 +115,7 @@ export class LocalHistoryProvider implements HistoryProvider {
         r.project,
         r.task,
         COUNT(*) AS total,
-        SUM(CASE WHEN r.status = 'success' THEN 1 ELSE 0 END) AS successes,
+        SUM(CASE WHEN r.status IN ${PASS_STATUSES} THEN 1 ELSE 0 END) AS successes,
         SUM(CASE WHEN r.cache_hit = 1 THEN 1 ELSE 0 END) AS hits,
         SUM(CASE WHEN r.status = 'failed' THEN 1 ELSE 0 END) AS failures,
         SUM(CASE WHEN r.attempts > 1 THEN 1 ELSE 0 END) AS retried,
@@ -159,21 +166,21 @@ export class LocalHistoryProvider implements HistoryProvider {
     // nondeterminism); a green history never pays for it.
     const mixed = this.mixedOutcomeKeys(
       floor,
-      rows.filter((r) => (r.failures || 0) > 0 && (r.retried || 0) === 0),
+      rows.filter((r) => r.failures > 0 && r.retried === 0),
     )
 
     for (const row of rows) {
       const key = `${row.project}#${row.task}`
-      const total = row.total || 0
-      const counts = { total, failures: row.failures || 0, retried: row.retried || 0 }
+      const total = row.total
+      const counts = { total, failures: row.failures, retried: row.retried }
       const durations = row.ds === null ? undefined : row.ds.split(',').map(Number)
       if (durations !== undefined) durations.sort((a, b) => a - b)
       out.set(key, {
         runs: total,
         p50DurationMs: durations ? pickPercentile(durations, 0.5) : undefined,
         p99DurationMs: durations ? pickPercentile(durations, 0.99) : undefined,
-        successRate: total > 0 ? (row.successes || 0) / total : 0,
-        hitRate: total > 0 ? (row.hits || 0) / total : 0,
+        successRate: row.successes / total,
+        hitRate: row.hits / total,
         failureMode: failureModeOf(counts, () => mixed.get(key) ?? 0),
         ...(row.rss !== null ? { maxPeakRssBytes: row.rss } : {}),
         ...(row.cpu !== null ? { maxCpuParallelism: row.cpu } : {}),
@@ -207,8 +214,8 @@ export class LocalHistoryProvider implements HistoryProvider {
   }
 }
 
+// A group holds at least one row, so every SUM is a number and `sorted` is
+// never empty; q < 1 keeps the index inside it.
 function pickPercentile(sorted: number[], q: number): number {
-  if (sorted.length === 0) return 0
-  const idx = Math.min(sorted.length - 1, Math.floor(q * sorted.length))
-  return sorted[idx]!
+  return sorted[Math.floor(q * sorted.length)]!
 }

package/src/orchestrator/summary.ts

@@ -260,12 +260,37 @@ export function formatSummarySection(
       )
     }
     lines.push('', row('info', join(info)), row('time', `${formatDuration(totalMs)}${spread}`))
+    // The run in one line, last, where the eye lands: what a Turbo user
+    // reads first in its own summary (tasks, cached, time), in vx's words.
+    if (stats.total > 0) lines.push(row('result', resultLine(stats, hits, totalMs, colors)))
   } else {
     lines.push('', row('time', `${formatDuration(totalMs)}${spread}`))
   }
   return lines
 }
 
+/**
+ * `42 tasks · 38 cached (90%) · 3.2s`, `2 tasks · all cached · 23ms`,
+ * with the failures first when there are any. Cached is every hit (up to
+ * date, restored locally or remotely) over every counted task.
+ */
+function resultLine(
+  stats: SummaryStats,
+  hits: number,
+  totalMs: number,
+  colors: ColorSupport,
+): string {
+  const parts = [`${stats.total} task${stats.total === 1 ? '' : 's'}`]
+  if (stats.failed > 0) parts.push(paint(ERROR, `${stats.failed} failed`, colors, { bold: true }))
+  parts.push(
+    hits === stats.total
+      ? paint(SUCCESS, 'all cached', colors, { bold: true })
+      : `${hits} cached (${Math.floor((hits / stats.total) * 100)}%)`,
+  )
+  parts.push(formatDuration(totalMs))
+  return parts.join(` ${paint('', '\u00b7', colors, { dim: true })} `)
+}
+
 // Local byte formatter — the orchestrator can't import cli/format.ts
 // (module boundary), and the footer only needs one compact form.
 export function formatRunSummary(