@vzn/vx 0.0.651 → 0.0.653

package/src/graph/task-status.ts

@@ -16,7 +16,11 @@ export type TaskStatus =
   // are partial.
   | 'aborted'
 
-/** Where a task's result came from, derived ONCE in core from the status. */
+/**
+ * Where a task's result came from, derived ONCE in core from the status.
+ * `none`: it never engaged the cache, or its hit's restore failed (a
+ * failed task, in no cache column).
+ */
 export type CacheSource = 'miss' | 'local' | 'remote' | 'none'
 
 /**

package/src/handoff.ts

@@ -2,8 +2,9 @@
 // from the workspace root, the one lookup every verb shares. Here for
 // the compiled binary installed by hand; an npm install's launcher
 // (npm-launcher.sh) walks the same way and `exec`s, which Bun cannot. The
-// walk runs before anything else loads, through `Bun.file(…).exists()`:
-// importing `node:fs` alone was ~1.1 ms of a 4 ms start (2026-10-13).
+// walk runs before anything else loads, through `Bun.Glob` and
+// `Bun.file(…).exists()`: importing `node:fs` alone was ~1.1 ms of a 4 ms
+// start (2026-10-13).
 
 /** `vx upgrade -g`: moves only the global vx, so it never hands off (2026-10-16). */
 export function upgradesOnlyItself(argv: readonly string[]): boolean {
@@ -85,21 +86,55 @@ export function workspaceFile(dir: string): Promise<string | null> {
 /** vx wrote a workspace config (`vx init`): what was learned before it is stale. */
 export function workspaceFileWritten(): void {
   files.clear()
+  broken.clear()
+}
+
+const workspaceNames = new Bun.Glob('workspace.*')
+const broken = new Set<string>()
+
+/**
+ * The workspace config in `d`'s `.vx`: the first of the names that is a
+ * file, else the first entry by one of them (a broken link, a directory),
+ * which marks the root all the same, as `vx lock`'s discovery counts it,
+ * and is refused there ({@link workspaceFileBroken}). A level without
+ * one costs a stat and a failed open, where a stat per name was six:
+ * 9 us against 15 us from three levels down, 1 us at a root holding
+ * `.vx/workspace.ts` either way (min of 2000, 2026-11-07).
+ */
+async function workspaceEntryIn(d: string): Promise<string | null> {
+  // The name `vx init` writes, first: at the root, the stat it always was.
+  const first = `${d}/${WORKSPACE_CONFIG_FILENAMES[0]}`
+  if (await Bun.file(first).exists()) return first
+  let names: string[]
+  try {
+    names = [...workspaceNames.scanSync({ cwd: `${d}/.vx`, onlyFiles: false })]
+  } catch {
+    return null
+  }
+  const ranked = WORKSPACE_CONFIG_FILENAMES.filter((n) => names.includes(n.slice(4)))
+  if (ranked.length === 0) return null
+  // `exists()` is false for a directory and a broken link.
+  for (const name of ranked)
+    if (name !== WORKSPACE_CONFIG_FILENAMES[0] && (await Bun.file(`${d}/${name}`).exists()))
+      return `${d}/${name}`
+  const file = `${d}/${ranked[0]}`
+  broken.add(file)
+  return file
+}
+
+/** The workspace config {@link workspaceFile} found is no file: a broken link, a directory. */
+export function workspaceFileBroken(file: string): boolean {
+  return broken.has(file)
 }
 
 async function findWorkspaceFile(start: string): Promise<string | null> {
   let top = await gitTop(start)
   const passed: string[] = []
   let found: string | null = null
-  walk: for (let d = start; ; d = d.slice(0, d.lastIndexOf('/'))) {
+  for (let d = start; ; d = d.slice(0, d.lastIndexOf('/'))) {
     passed.push(d || '/')
-    for (const name of WORKSPACE_CONFIG_FILENAMES) {
-      const file = `${d}/${name}`
-      if (await Bun.file(file).exists()) {
-        found = file
-        break walk
-      }
-    }
+    found = await workspaceEntryIn(d)
+    if (found !== null) break
     if (d === '') break
     if (d === top) {
       // A submodule whose `.git` is a directory (added from a clone, not

package/src/history/failure-mode.ts

@@ -30,7 +30,7 @@ export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
  * `status`, `cache_hit`, `cached` columns) with how often it failed, how often it
  * passed — an executed success or a cache hit, which replays a success —
  * and how often it failed AFTER its first pass (`relapses`). A task with
- * no cache block keys on its config alone and runs every time, so its key
+ * no `cache: true` keys on its config alone and runs every time, so its key
  * says nothing about its inputs: no reader counts it, as no run's row
  * calls it flaky. Nor is a row that names a `blocked_by`: it ran behind a
  * failure (`--continue=always`), on bytes its key never named, so its
@@ -75,7 +75,7 @@ export function mixedOutcomeKeysSql(source: string, where = ''): string {
 export function mixedOutcomeKeyCount(db: Database, project: string, task: string): number {
   const row = db
     .query(
-      `SELECT COUNT(*) AS n FROM (${mixedOutcomeKeysSql('runs', ' AND project = ? AND task = ?')})`,
+      `SELECT COUNT(*) AS n FROM (${mixedOutcomeKeysSql('main.runs', ' AND project = ? AND task = ?')})`,
     )
     .get(project, task) as { n: number }
   return row.n
@@ -198,6 +198,29 @@ export function detectFlaky(db: Database, candidates: readonly FlakyCandidate[])
   return out
 }
 
+/**
+ * Whether a task that just failed on `hash` is known to be flaky: this key
+ * passed before (the failure itself is the flake), or the retained history
+ * holds a key of the task that failed after it passed, or a pass that took
+ * a retry. Asked only after a failure, so a green run never reads it.
+ */
+export function knownFlaky(db: Database, project: string, task: string, hash: string): boolean {
+  const passed = db
+    .query(
+      `SELECT 1 FROM ${OUTCOMES} WHERE hash = ? AND project = ? AND task = ?
+       AND (status = 'success' OR status IN ${HIT_STATUSES}) LIMIT 1`,
+    )
+    .get(hash, project, task)
+  if (passed !== null) return true
+  const flaked = db
+    .query(
+      `SELECT 1 FROM (${keyOutcomesSql(OUTCOMES, ' AND project = ? AND task = ?')})
+       WHERE relapses > 0 OR retried_failures > 0 LIMIT 1`,
+    )
+    .get(project, task)
+  return flaked !== null
+}
+
 /** One task the recorded history shows failing on a key that had passed. */
 export interface FlakyTask {
   /** `project#task`. */
@@ -213,18 +236,28 @@ export interface FlakyTask {
 
 /**
  * Every task with a key that failed after it had passed anywhere in the retained history
- * (30 days, `RunHistory.pruneOlderThan`), most failures first: the
+ * (until a bounded clean's `RunHistory.pruneOlderThan`), most failures first: the
  * doctor's list. A pass that took a retry mixes its key on its own: it is
  * one `success` row whose failed attempts count as failures (`vx info`
- * said `none` over one). A full scan of `task_outcomes`, which an inspection verb
- * affords.
+ * said `none` over one). Only keys with a failure or a retry can be on it,
+ * so one plain pass over `task_outcomes` finds those and the projection
+ * reads their rows alone, by `task_outcomes_hash`: projecting every key
+ * sorted the whole table, 4.2 s at 2M rows against 0.15. An index on the
+ * candidates would make the pass a probe; it is a schema change, which
+ * resets every cache.
  */
 export function flakyTasks(db: Database): FlakyTask[] {
   const rows = db
     .query(
       `SELECT project, task, COUNT(*) AS keys, SUM(passes) AS passes, SUM(failures) AS failures
        FROM (SELECT project, task, passes, failures + retried_failures AS failures
-             FROM (${keyOutcomesSql(OUTCOMES)})
+             FROM (${keyOutcomesSql(
+               OUTCOMES,
+               // NOT INDEXED: by `task_outcomes_hash` the pass looked each
+               // row up from the index, 1.1 s against 0.15.
+               ` AND hash IN (SELECT hash FROM ${OUTCOMES} NOT INDEXED
+                              WHERE attempts > 1 OR status = 'failed')`,
+             )})
              WHERE relapses > 0 OR retried_failures > 0)
        GROUP BY project, task
        ORDER BY failures DESC, passes DESC, project, task`,

package/src/history/history.ts

@@ -121,6 +121,8 @@ export class EmptyHistoryProvider implements HistoryProvider {
 export interface LocalHistory extends HistoryProvider {
   /** Each task's measured need (`p50DurationMs`, peak cores and memory). */
   resourcesFor(taskIds: readonly string[]): Promise<ReadonlyMap<string, TaskResources>>
+  /** Only each task's `p50DurationMs` as `resourcesFor` answers it, read without the rest. */
+  durationsFor(taskIds: readonly string[]): Promise<ReadonlyMap<string, number>>
   /** Whether timings of commit `sha` were imported. */
   hasImported(sha: string): boolean
   /** Keep commit `sha`'s timings (task id → ms) and needs as forecast rows. */
@@ -243,7 +245,7 @@ export class LocalHistoryProvider implements LocalHistory {
                    THEN ${NEED_SQL} END),
           MAX(CASE WHEN r.cache_hit = 1 AND e.cpu_ms IS NOT NULL AND e.duration_ms > 0
                    THEN e.cpu_ms * 1.0 / e.duration_ms END)) AS cpu
-      FROM runs r
+      FROM main.runs r
       -- A hit executed nothing here, but its entry carries what the
       -- PRODUCING execution used (the artifact's sidecar, indexed at save
       -- and ingest alike), so a task this machine has only ever restored
@@ -400,6 +402,13 @@ export class LocalHistoryProvider implements LocalHistory {
     const out = new Map<string, number>()
     this.lackedBranchHistory = false
     if (wanted.size === 0) return out
+    // A store that has timed nothing (a cold cache, a first run) answers no
+    // tier: one row's probe, where asking every task of 8,002 was 20 ms of
+    // a cold run's schedule stage (2026-11-07).
+    if (this.db.query('SELECT 1 FROM task_durations LIMIT 1').get() === null) {
+      this.lackedBranchHistory = true
+      return out
+    }
     // Tiers, first answer wins: a WHERE over `task_durations`, its params,
     // and how many of the newest rows it reads.
     type Tier = { where: string; params: string[]; limit: number }
@@ -480,7 +489,7 @@ export class LocalHistoryProvider implements LocalHistory {
         `SELECT r.project, r.task${this.byDef}, MAX(r.peak_rss_bytes) AS rss,
            AVG(CASE WHEN r.cpu_ms IS NOT NULL AND r.duration_ms > 0
                     THEN ${NEED_SQL} END) AS cpu
-         FROM runs r
+         FROM main.runs r
          WHERE r.id >= ? AND r.status = 'success' AND (r.cache_hit IS NULL OR r.cache_hit = 0)
          GROUP BY r.project, r.task${this.byDef}`,
       )
@@ -495,25 +504,7 @@ export class LocalHistoryProvider implements LocalHistory {
         ...(row.cpu !== null ? { maxCpuParallelism: row.cpu } : {}),
       })
     }
-    type Hit = {
-      project: string
-      task: string
-      def?: string | null
-      rss: number | null
-      cpu: number | null
-      ms: number | null
-    }
-    const hits = this.db
-      .query(
-        `SELECT r.project, r.task${this.byDef}, MAX(e.peak_rss_bytes) AS rss,
-           MAX(CASE WHEN e.cpu_ms IS NOT NULL AND e.duration_ms > 0
-                    THEN e.cpu_ms * 1.0 / e.duration_ms END) AS cpu,
-           MAX(CASE WHEN e.duration_ms > 0 THEN e.duration_ms END) AS ms
-         FROM (SELECT DISTINCT project, task, hash, def FROM runs WHERE id >= ? AND cache_hit = 1) r
-         JOIN entries e ON e.hash = r.hash
-         GROUP BY r.project, r.task${this.byDef}`,
-      )
-      .all(floor) as Hit[]
+    const hits = this.producerRows(floor)
     // A hit's CPU is its producer's use, not need: the entry keeps no
     // share, so a crowded producer's reads low. Only a task with no need
     // from a run here or the default branch's import takes it: main's
@@ -522,12 +513,7 @@ export class LocalHistoryProvider implements LocalHistory {
     const hitCpu = new Map<string, number>()
     for (const row of hits) {
       const key = `${row.project}#${row.task}`
-      if (
-        !wanted.has(key) ||
-        !this.current(key, row.def) ||
-        (row.rss === null && row.cpu === null && row.ms === null)
-      )
-        continue
+      if (!wanted.has(key) || !this.produced(key, row)) continue
       if (row.cpu !== null) hitCpu.set(key, row.cpu)
       const had = out.get(key)
       const rss = Math.max(had?.maxPeakRssBytes ?? -Infinity, row.rss ?? -Infinity)
@@ -558,7 +544,7 @@ export class LocalHistoryProvider implements LocalHistory {
                  AVG(${NEED_SQL} / r.placement_cores) AS fill,
                  MAX(CASE WHEN r.peak_rss_bytes >= ${SATURATED} * r.placement_memory
                           THEN r.placement_memory END) AS memory
-               FROM runs r
+               FROM main.runs r
                WHERE r.id >= ? AND r.placement_cores IS NOT NULL AND r.duration_ms > 0
                  AND r.status IN ('success', 'failed') AND (r.cache_hit IS NULL OR r.cache_hit = 0)
                GROUP BY r.project, r.task${this.byDef}, r.placement_cores) r
@@ -589,6 +575,51 @@ export class LocalHistoryProvider implements LocalHistory {
     return out
   }
 
+  /**
+   * Only the `p50DurationMs` of each task `resourcesFor` answers: its
+   * forecast, else a restored task's producer time. For a reader that
+   * needs nothing else (`@vzn/vx-history`'s timings file): the window's
+   * grouped reads are skipped, and the hits are read only when some task
+   * has no forecast. 23-27 ms against 40 at 8,002 tasks.
+   */
+  async durationsFor(taskIds: readonly string[]): Promise<ReadonlyMap<string, number>> {
+    if (taskIds.length === 0) return new Map()
+    const wanted = new Set(taskIds)
+    const out = this.forecasts(wanted)
+    if (out.size === wanted.size) return out
+    // As `resourcesFor` sets it: the last row of a task wins, a row of no time unsetting it.
+    const produced = new Map<string, number | null>()
+    for (const row of this.producerRows(this.floor())) {
+      const key = `${row.project}#${row.task}`
+      if (wanted.has(key) && !out.has(key) && this.produced(key, row)) produced.set(key, row.ms)
+    }
+    for (const [key, ms] of produced) if (ms !== null) out.set(key, ms)
+    return out
+  }
+
+  /**
+   * The window's restored tasks, by what their entries' producers used:
+   * each distinct hit key joined to its entry once.
+   */
+  private producerRows(floor: number): ProducerRow[] {
+    return this.db
+      .query(
+        `SELECT r.project, r.task${this.byDef}, MAX(e.peak_rss_bytes) AS rss,
+           MAX(CASE WHEN e.cpu_ms IS NOT NULL AND e.duration_ms > 0
+                    THEN e.cpu_ms * 1.0 / e.duration_ms END) AS cpu,
+           MAX(CASE WHEN e.duration_ms > 0 THEN e.duration_ms END) AS ms
+         FROM (SELECT DISTINCT project, task, hash, def FROM main.runs WHERE id >= ? AND cache_hit = 1) r
+         JOIN entries e ON e.hash = r.hash
+         GROUP BY r.project, r.task${this.byDef}`,
+      )
+      .all(floor) as ProducerRow[]
+  }
+
+  /** Whether a producer row is of the task as it is now and measured anything. */
+  private produced(key: string, row: ProducerRow): boolean {
+    return this.current(key, row.def) && (row.rss !== null || row.cpu !== null || row.ms !== null)
+  }
+
   /**
    * A task never measured here takes its need from the newest imported
    * row that has one (`importTimings`): a fresh CI machine packs by what
@@ -641,6 +672,38 @@ export class LocalHistoryProvider implements LocalHistory {
     }
   }
 
+  /**
+   * Of `taskIds`, each whose one timing (of its definition, given `defs`)
+   * was recorded at or after `since`: a run's own, with no usual to compare
+   * it with. At most two rows per task off `task_durations_task`, where
+   * grouping every task's rows cost `vx last` 1.5 s at 2M rows.
+   */
+  timedOnlySince(taskIds: readonly string[], since: number): string[] {
+    if (taskIds.length === 0) return []
+    const rows = this.db
+      .query(
+        `SELECT j.key AS i FROM json_each(?) AS j
+         WHERE (SELECT MIN(recorded_at) FROM (
+             SELECT recorded_at FROM task_durations
+             WHERE project = j.value ->> 0 AND task = j.value ->> 1 ${this.durationDef}
+             LIMIT 2) HAVING COUNT(*) = 1) >= ?`,
+      )
+      .all(JSON.stringify(taskIds.map((id) => this.keyOf(id))), since) as { i: number }[]
+    return rows.map((r) => taskIds[r.i]!)
+  }
+
+  /**
+   * Each task id the window's rows name, sorted: what a mistyped id is
+   * matched against. Every pair of the whole table was a scan of it, 270 ms
+   * at 2M rows, on an error's path.
+   */
+  recentTaskIds(): string[] {
+    const rows = this.db
+      .query('SELECT DISTINCT project, task FROM main.runs WHERE id >= ? ORDER BY project, task')
+      .all(this.floor()) as { project: string; task: string }[]
+    return rows.map((r) => `${r.project}#${r.task}`)
+  }
+
   /** The first `runs` id of the newest `recent` invocations (see `loadFor`). */
   private floor(): number {
     // The first row of each invocation in the window, an index probe each:
@@ -649,7 +712,7 @@ export class LocalHistoryProvider implements LocalHistory {
     const row = this.db
       .query(
         `SELECT COUNT(*) AS n, MIN(first) AS id,
-           (SELECT COALESCE(MAX(id), 0) + 1 FROM runs) AS past
+           (SELECT COALESCE(MAX(id), 0) + 1 FROM main.runs) AS past
          FROM (SELECT (SELECT MIN(id) FROM runs WHERE run_id = i.run_id) AS first
                FROM (SELECT run_id FROM invocations ORDER BY rowid DESC LIMIT ?) i)`,
       )
@@ -671,7 +734,7 @@ export class LocalHistoryProvider implements LocalHistory {
     const rows = this.db
       .query(
         `SELECT project, task, COUNT(*) AS n FROM (${mixedOutcomeKeysSql(
-          'runs',
+          'main.runs',
           ` AND id >= ? AND (project, task) IN (VALUES ${placeholders})`,
         )}) GROUP BY project, task`,
       )
@@ -685,6 +748,16 @@ export class LocalHistoryProvider implements LocalHistory {
   }
 }
 
+/** A restored task's producer use, from the window's hits (`producerRows`). */
+interface ProducerRow {
+  project: string
+  task: string
+  def?: string | null
+  rss: number | null
+  cpu: number | null
+  ms: number | null
+}
+
 // 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 {

package/src/history/index.ts

@@ -16,6 +16,7 @@ export {
 } from './history.js'
 export {
   detectFlaky,
+  knownFlaky,
   type FailureMode,
   type FlakyCandidate,
   type FlakyFinding,
@@ -32,6 +33,7 @@ export {
   latestRunId,
   listInvocations,
   listRuns,
+  recordedTasks,
   rootCauses,
   upstreamTask,
   whyDidThisRerun,