@vzn/vx 0.0.631 → 0.0.632

package/src/orchestrator/path-links.ts

@@ -0,0 +1,79 @@
+// A failed task's output with each file it names made a terminal link
+// (OSC 8). A tool prints paths relative to where it ran, the task's
+// project, so the terminal's own path detection, which resolves against
+// the shell's directory, opens the wrong file or none in a monorepo. The
+// visible text stays the task's bytes; only the link target is vx's.
+
+import { statSync } from 'node:fs'
+import path from 'node:path'
+
+// `src/a.ts`, `./a.ts:12`, `/abs/a.ts:12:5`, tsc's `src/a.ts(12,5)`. Not
+// after a word, dot, slash or `@`, so a URL's path or a scoped name's tail
+// never starts a match. Groups: file, then line and column of either form.
+const PATH =
+  /(?<![\w./@+-])((?:\/|\.{1,2}\/)?(?:[\w@.+-]+\/)*[\w@+-][\w@.+-]*\.[A-Za-z][A-Za-z0-9]{0,9})(?::(\d+)(?::(\d+))?|\((\d+),(\d+)\))?/g
+
+/** A file a task's output names; `file` absolute. */
+export interface OutputLocation {
+  file: string
+  line?: number
+  col?: number
+}
+
+/** Most locations one output reports: past it, the first ones are the cause. */
+const LOCATIONS_CAP = 50
+
+/** `text` with every path that names a file under `dir` (or an absolute one) linked. */
+export function linkPaths(text: string, dir: string, isFile: (abs: string) => boolean): string {
+  if (text.includes('\x1b]8;')) return text
+  return text.replace(PATH, (match: string, file: string) => {
+    const abs = path.resolve(dir, file)
+    if (!isFile(abs)) return match
+    return `\x1b]8;;file://${encodeURI(abs)}\x1b\\${match}\x1b]8;;\x1b\\`
+  })
+}
+
+/**
+ * The files `text` names that exist (resolved against `dir`), each with the
+ * line and column it gave, unique, in order of first appearance.
+ */
+export function fileLocations(
+  text: string,
+  dir: string,
+  isFile: (abs: string) => boolean,
+): OutputLocation[] {
+  const out: OutputLocation[] = []
+  const seen = new Set<string>()
+  for (const m of text.matchAll(PATH)) {
+    const file = path.resolve(dir, m[1]!)
+    const line = m[2] ?? m[4]
+    const col = m[3] ?? m[5]
+    const id = `${file}:${line}:${col}`
+    if (seen.has(id) || !isFile(file)) continue
+    seen.add(id)
+    out.push({
+      file,
+      ...(line !== undefined ? { line: Number(line) } : {}),
+      ...(col !== undefined ? { col: Number(col) } : {}),
+    })
+    if (out.length === LOCATIONS_CAP) break
+  }
+  return out
+}
+
+/** A file test that asks the file system once per path. */
+export function fileMemo(): (abs: string) => boolean {
+  const seen = new Map<string, boolean>()
+  return (abs) => {
+    let known = seen.get(abs)
+    if (known === undefined) {
+      try {
+        known = statSync(abs).isFile()
+      } catch {
+        known = false
+      }
+      seen.set(abs, known)
+    }
+    return known
+  }
+}

package/src/orchestrator/plan.ts

@@ -15,6 +15,7 @@ import type { CacheLayer, CachePolicy, GitFilesCache } from '../cache/index.js'
 import { cachesNothing, FULL_CACHE_POLICY } from '../cache/index.js'
 import { ranNoCache } from './events.js'
 import { idleServers, isGroupTask, runGraph, type TaskNode } from '../graph/index.js'
+import type { AffectedReason } from './affected-tasks.js'
 import type { HistoryProvider } from './history.js'
 import { computeGroupKey, computeTaskHash } from './task-hash.js'
 import { keyedOutcome, keyUpstream } from './upstream.js'
@@ -53,6 +54,8 @@ export interface PlannedTask {
    * eager task is the default and saying so on every line says nothing.
    */
   download?: 'deferred'
+  /** Why `--affected` kept this requested task; absent without `--affected` and on a dependency it pulled in. */
+  affected?: AffectedReason
 }
 
 /**
@@ -68,6 +71,9 @@ export interface PlanPrediction {
   /** Would-run tasks with NO history — their cost is unknown and counted as
    *  0, so wallMs/workMs are lower bounds when this is > 0. */
   unknownCount: number
+  /** The would-run tasks with history along the chain `wallMs` measures,
+   *  dependencies first; empty when nothing with history would run. */
+  criticalPath: string[]
 }
 
 export interface RunPlan {
@@ -271,19 +277,27 @@ function predictPlan(tasks: PlannedTask[]): PlanPrediction {
   const dist = new Map<string, number>()
   const queue: string[] = []
   for (const [id, n] of indeg) if (n === 0) queue.push(id)
+  const via = new Map<string, string>()
   let head = 0
   let wallMs = 0
+  let end: string | undefined
   while (head < queue.length) {
     const id = queue[head++]!
     const t = byId.get(id)!
     let best = 0
     for (const d of t.deps) {
       const v = dist.get(d)
-      if (v !== undefined && v > best) best = v
+      if (v !== undefined && v > best) {
+        best = v
+        via.set(id, d)
+      }
     }
     const v = best + cost(t)
     dist.set(id, v)
-    if (v > wallMs) wallMs = v
+    if (v > wallMs) {
+      wallMs = v
+      end = id
+    }
     for (const dep of dependents.get(id) ?? []) {
       const n = indeg.get(dep)! - 1
       indeg.set(dep, n)
@@ -297,5 +311,8 @@ function predictPlan(tasks: PlannedTask[]): PlanPrediction {
     if (t.p50Ms === undefined) unknownCount++
     else workMs += t.p50Ms
   }
-  return { wallMs, workMs, unknownCount }
+  const criticalPath: string[] = []
+  for (let id = end; id !== undefined; id = via.get(id))
+    if (cost(byId.get(id)!) > 0) criticalPath.push(id)
+  return { wallMs, workMs, unknownCount, criticalPath: criticalPath.reverse() }
 }

package/src/orchestrator/plugin.ts

@@ -251,6 +251,13 @@ export interface CommandContext extends BaseContext {
    * `machineParallelism()` said 4 cores beside `concurrency: 1` (item 1068).
    */
   readonly concurrency: number
+  /**
+   * The argv that runs this vx again: the binary alone when compiled, the
+   * runtime and its entry script from source. A verb that runs tasks
+   * (`vx mcp`'s `runTasks`) spawns `[...vx, 'run', …]` rather than guess
+   * which `vx` a PATH holds.
+   */
+  readonly vx: readonly string[]
 }
 
 /** `config` runs before the cache dir is known — it may be what the hook changes. */

package/src/orchestrator/prepare.ts

@@ -74,6 +74,7 @@ import type { VxPlugin } from './plugin.js'
 import { createHashCache, type HashCache } from './task-hash.js'
 import type { Logger } from './logger.js'
 import type { RunOptions } from './options.js'
+import { refuseFiltersThroughGroups } from './upstream.js'
 
 export interface PreparedRun {
   workspaceRoot: string
@@ -549,10 +550,18 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     if (options.affected !== undefined) {
       const before = hooksFirst ? new Set(nodes.keys()) : null
       if (hooksFirst) await graphStage()
-      const kept = keptByAffected(nodes, requested, options.affected, projects, packageGraph, {
-        named: new Set(tasks.filter((t) => t.includes('#'))),
-        outright: new Set(options.selectedOutright),
-      })
+      const kept = keptByAffected(
+        nodes,
+        requested,
+        options.affected,
+        projects,
+        packageGraph,
+        {
+          named: new Set(tasks.filter((t) => t.includes('#'))),
+          outright: new Set(options.selectedOutright),
+        },
+        options.affectedReasons && { workspaceRoot, reasons: options.affectedReasons },
+      )
       if (kept.length === 0) return emptyRun('none-affected')
       if (before !== null) {
         const asked = new Set(requested.map((r) => `${r.project}#${r.task}`))
@@ -656,6 +665,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     if (hasHook(plugins, 'key')) {
       await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: (m) => log.status(m) })
     }
+    refuseFiltersThroughGroups(nodes)
     const exclude = options.excludeDependencies
     let keyOnly: ReadonlyMap<string, TaskNode> = new Map()
     if (exclude !== undefined && (exclude === 'all' || exclude.length > 0)) {

package/src/orchestrator/run-artifacts.ts

@@ -52,6 +52,7 @@ export interface SummaryTaskJson {
   flaky?: { passes: number; failures: number; attempts: number }
   cpuMs?: number
   peakRssBytes?: number
+  storedDurationMs?: number
   storedCpuMs?: number
   storedPeakRssBytes?: number
   admissionHeldMs?: number
@@ -71,6 +72,8 @@ export interface RunSummaryJson {
   startedAt: string
   endedAt: string
   totalMs: number
+  /** What the hits skipped: the sum of their `storedDurationMs`. */
+  savedMs: number
   tasks: SummaryTaskJson[]
   aborted: SummaryTaskJson[]
   summary: Tally
@@ -105,6 +108,7 @@ function taskEntry(o: TaskOutcome, flaky?: FlakyFinding): SummaryTaskJson {
     ...(o.peakRssBytes !== undefined ? { peakRssBytes: o.peakRssBytes } : {}),
     // A hit's row names what the PRODUCING execution used under its own
     // keys, so a consumer never reads a remote worker's peak as this run's.
+    ...(o.storedDurationMs !== undefined ? { storedDurationMs: o.storedDurationMs } : {}),
     ...(o.storedCpuMs !== undefined ? { storedCpuMs: o.storedCpuMs } : {}),
     ...(o.storedPeakRssBytes !== undefined ? { storedPeakRssBytes: o.storedPeakRssBytes } : {}),
     // Present only when an `admit` policy held the task with a worker free.
@@ -130,6 +134,14 @@ export async function writeRunSummary(args: SummarizeArgs): Promise<string> {
     args.target === ''
       ? path.join(args.cacheDir, 'runs', `${args.runId}.json`)
       : path.resolve(args.cwd, args.target)
+  await Bun.write(outPath, JSON.stringify(runSummaryJson(args), null, 2))
+  return outPath
+}
+
+/** The `--summarize` document, which `vx run --format json` prints. */
+export function runSummaryJson(
+  args: Omit<SummarizeArgs, 'target' | 'cacheDir' | 'cwd'>,
+): RunSummaryJson {
   // `tasks` and `summary` must describe the same population, or one artifact
   // contradicts itself (a group task listed in `tasks` but absent from
   // `summary.total`). `tallyOutcomes` owns the rule; mirror its filter here.
@@ -151,6 +163,11 @@ export async function writeRunSummary(args: SummarizeArgs): Promise<string> {
     startedAt: new Date(args.startedAtMs).toISOString(),
     endedAt: new Date(args.endedAtMs).toISOString(),
     totalMs: args.totalMs,
+    // The summary row's `saved`, by the same rule: hits only, groups aside.
+    savedMs: counted.reduce(
+      (ms, o) => (isCacheHit(o.status) ? ms + (o.storedDurationMs ?? 0) : ms),
+      0,
+    ),
     tasks: counted.map((o) => taskEntry(o, flakyById.get(o.node.id))),
     aborted: aborted.map((o) => taskEntry(o)),
     // The FULL list: `tallyOutcomes` applies the same group/aborted
@@ -158,8 +175,7 @@ export async function writeRunSummary(args: SummarizeArgs): Promise<string> {
     // it — but `summary.aborted` is only non-zero if it sees them.
     summary: tallyOutcomes(args.outcomes),
   }
-  await Bun.write(outPath, JSON.stringify(payload, null, 2))
-  return outPath
+  return payload
 }
 
 export interface ProfileArgs {

package/src/orchestrator/run-failures.ts

@@ -0,0 +1,192 @@
+// A failed run's task output and the files it names, so an agent reads why
+// a task failed without the terminal (`vx last --format json`, vx-mcp's
+// getFailures). One file per failed run, `<cacheDir>/failures/<runId>.json`,
+// the newest 50 kept: files, not cache.db, so the index layout (and every
+// shared store under it) stays as it was.
+
+import type { Database } from 'bun:sqlite'
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { isGroupTask, type TaskOutcome } from '../graph/index.js'
+import { decodeOutputLog } from './output-log.js'
+import { splitTaskId } from '../util/index.js'
+import { fileLocations, fileMemo, type OutputLocation } from './path-links.js'
+
+/** Failed runs whose output is kept; run ids are UUIDv7, so names sort by age. */
+const KEPT = 50
+
+/** A failed task of a run and what it said. */
+export interface TaskFailure {
+  taskId: string
+  exitCode: number
+  timedOut?: true
+  /** Plain text, bounded, secrets masked; '' when the run kept none. */
+  output: string
+  locations: OutputLocation[]
+}
+
+export interface RunFailures {
+  runId: string
+  tasks: TaskFailure[]
+}
+
+interface StoredFailure extends TaskFailure {
+  project: string
+  task: string
+}
+
+const dirOf = (cacheDir: string): string => path.join(cacheDir, 'failures')
+
+/** Each failed outcome's output as plain text and the files it names. */
+function failuresOf(outcomes: readonly TaskOutcome[]): StoredFailure[] {
+  const isFile = fileMemo()
+  const out: StoredFailure[] = []
+  for (const o of outcomes) {
+    if (o.failedOutput === undefined || isGroupTask(o.node)) continue
+    const output = Bun.stripANSI(
+      decodeOutputLog(o.failedOutput)
+        .map((c) => c.text)
+        .join(''),
+    )
+    out.push({
+      taskId: o.node.id,
+      project: o.node.projectName,
+      task: o.node.taskName,
+      exitCode: o.exitCode,
+      ...(o.timedOut === true ? { timedOut: true as const } : {}),
+      output,
+      locations: fileLocations(output, o.node.projectDir, isFile),
+    })
+  }
+  return out
+}
+
+/**
+ * Write the run's failures, when any outcome carries output, and drop all
+ * but the newest `KEPT` files. Atomic: a reader sees the whole file or none.
+ */
+export function writeRunFailures(
+  cacheDir: string,
+  runId: string,
+  outcomes: readonly TaskOutcome[],
+): void {
+  const tasks = failuresOf(outcomes)
+  if (tasks.length === 0) return
+  const dir = dirOf(cacheDir)
+  mkdirSync(dir, { recursive: true })
+  const file = path.join(dir, `${runId}.json`)
+  const tmp = `${file}.${process.pid}.tmp`
+  writeFileSync(tmp, JSON.stringify({ runId, tasks }))
+  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 })
+}
+
+/**
+ * The failed tasks of `runId`, or of the latest failed run when omitted;
+ * null when there is no such run. A failed task the file lacks (an older
+ * run, a write the disk refused) reads `output: ''`, `locations: []`.
+ */
+export function runFailures(cacheDir: string, db: Database, runId?: string): RunFailures | null {
+  const id =
+    runId ??
+    (
+      db
+        .query('SELECT run_id FROM invocations WHERE exit_ok = 0 ORDER BY rowid DESC LIMIT 1')
+        .get() as { run_id: string } | null
+    )?.run_id
+  if (id === undefined) return null
+  const kept = new Map<string, StoredFailure>()
+  try {
+    const stored = JSON.parse(
+      readFileSync(path.join(dirOf(cacheDir), `${id}.json`), 'utf8'),
+    ) as RunFailures & { tasks: StoredFailure[] }
+    for (const t of stored.tasks) kept.set(t.taskId, t)
+  } catch (err) {
+    // No file: the run kept no output.
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
+  }
+  const rows = db
+    .query(
+      `SELECT project, task, exit_code AS exitCode, timed_out AS timedOut FROM runs
+       WHERE run_id = ? AND status = 'failed' ORDER BY id`,
+    )
+    .all(id) as { project: string; task: string; exitCode: number; timedOut: number | null }[]
+  return {
+    runId: id,
+    tasks: rows.map((r) => {
+      const taskId = `${r.project}#${r.task}`
+      const k = kept.get(taskId)
+      return {
+        taskId,
+        exitCode: r.exitCode,
+        ...(r.timedOut === 1 ? { timedOut: true as const } : {}),
+        output: k?.output ?? '',
+        locations: k?.locations ?? [],
+      }
+    }),
+  }
+}
+
+/** One task's output in a recorded run, as `vx last --log` and getTaskLog read it. */
+export interface TaskLog {
+  runId: string
+  taskId: string
+  status: string
+  /**
+   * Where the output came from: the run's kept failure output, the cache
+   * entry the task saved or hit (masked as it was replayed), or null when
+   * vx kept none (an uncached task that passed, a skip).
+   */
+  source: 'failure' | 'cache' | null
+  /** Plain text; '' when `source` is null. The files it names: `runFailures`. */
+  output: string
+}
+
+/**
+ * `taskId`'s output in `runId`, or in the latest run that recorded the
+ * task when omitted; null when no such run recorded it.
+ */
+export function taskLog(
+  cacheDir: string,
+  db: Database,
+  taskId: string,
+  runId?: string,
+): TaskLog | null {
+  const [project, task] = splitTaskId(taskId)
+  if (project === '' || task === '') return null
+  const row = db
+    .query(
+      `SELECT run_id AS runId, hash, status FROM runs
+       WHERE project = ? AND task = ? AND run_id IS NOT NULL ${runId === undefined ? '' : 'AND run_id = ?'}
+       ORDER BY id DESC LIMIT 1`,
+    )
+    .get(...(runId === undefined ? [project, task] : [project, task, runId])) as {
+    runId: string
+    hash: string
+    status: string
+  } | null
+  if (row === null) return null
+  const base = { runId: row.runId, taskId, status: row.status }
+  if (row.status === 'failed') {
+    const kept = runFailures(cacheDir, db, row.runId)?.tasks.find((t) => t.taskId === taskId)
+    if (kept !== undefined && kept.output !== '') {
+      return { ...base, source: 'failure', output: kept.output }
+    }
+  } else if (row.hash !== '') {
+    const stored = db.query('SELECT stdout FROM entry_stdout WHERE hash = ?').get(row.hash) as {
+      stdout: string
+    } | null
+    if (stored !== null) {
+      const output = Bun.stripANSI(
+        decodeOutputLog(stored.stdout)
+          .map((c) => c.text)
+          .join(''),
+      )
+      return { ...base, source: 'cache', output }
+    }
+  }
+  return { ...base, source: null, output: '' }
+}

package/src/orchestrator/run-records.ts

@@ -14,8 +14,11 @@ import { isCacheHit, taskTelemetryOf, type TaskTelemetry } from './telemetry.js'
 
 export interface RunRecordsInput {
   outcomes: readonly TaskOutcome[]
-  /** Tasks that ran behind a failed dependency (`--continue=always`). */
-  tainted?: ReadonlySet<string>
+  /**
+   * Tasks that ran behind a failed dependency (`--continue=always`) or one
+   * `--exclude-dependencies` dropped, each with the task at the root of it.
+   */
+  tainted?: ReadonlyMap<string, string>
   runId: string
   /** Wall-clock ms at run start; every per-task ns offset is anchored to it. */
   startedAtMs: number
@@ -67,12 +70,9 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
     // aborted (killed by a shutdown signal) isn't a real run.
     if (o.status === 'aborted') continue
     if (input.withTelemetry) telemetryTasks.push(taskTelemetryOf(o))
+    const blockedBy = o.blockedBy ?? input.tainted?.get(o.node.id)
     runs.push({
-      // A failure behind a failed dependency is recorded keyless (`''`, which
-      // the key readers skip): the flaky list asks a key whether it failed.
-      ...(o.hash !== undefined && !(o.status === 'failed' && input.tainted?.has(o.node.id) === true)
-        ? { hash: o.hash }
-        : {}),
+      ...(o.hash !== undefined ? { hash: o.hash } : {}),
       project: o.node.projectName,
       task: o.node.taskName,
       status: o.status,
@@ -107,7 +107,9 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
       ...(isCacheHit(o.status) ? { restored: o.restored === true } : {}),
       ...(o.attempts !== undefined ? { attempts: o.attempts } : {}),
       cached: o.node.config.cache !== undefined,
-      ...(o.blockedBy !== undefined ? { blockedBy: o.blockedBy } : {}),
+      // 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 } : {}),