@vzn/vx 0.0.16 → 0.0.18

package/src/orchestrator/failure-mode.ts

@@ -0,0 +1,61 @@
+// The flakiness verdict, in ONE place. Two surfaces classify the same
+// `runs` rows — the run-history readers and `LocalHistoryProvider` (what
+// `--dry` predictions read) — and they used
+// to encode the rule independently, which let them drift into opposite
+// verdicts on identical data. Both now call `classifyFailureMode`, so the
+// rule cannot fork again.
+
+import type { Database } from 'bun:sqlite'
+import { KEYED_RUNS_SQL } from '../cache/index.js'
+import { isCacheHit, TASK_STATUSES } from './telemetry.js'
+
+// SQL hit set derived from the predicate — never a hand-typed list and never
+// a prefix LIKE (a prefix counts any status merely NAMED cache-hit-*). The
+// status-vocabulary tripwire greps both wrong forms.
+const HIT_STATUSES = `(${TASK_STATUSES.filter(isCacheHit)
+  .map((s) => `'${s}'`)
+  .join(', ')})`
+
+export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
+
+/**
+ * Distinct cache keys that produced BOTH a failure and a success — the
+ * definitional flake: identical inputs, different outcomes. A failure whose
+ * key never succeeded is a legitimate break (a changed input that fails),
+ * which belongs to the regressions surface, not flakiness.
+ */
+export function mixedOutcomeKeyCount(db: Database, project: string, task: string): number {
+  const row = db
+    .query(
+      `SELECT COUNT(*) AS n FROM (
+         SELECT hash FROM runs
+         WHERE project = ? AND task = ? AND ${KEYED_RUNS_SQL}
+         GROUP BY hash
+         HAVING SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) > 0
+            AND SUM(CASE WHEN status = 'success' OR status IN ${HIT_STATUSES} OR cache_hit = 1
+                    THEN 1 ELSE 0 END) > 0
+       )`,
+    )
+    .get(project, task) as { n: number }
+  return row.n
+}
+
+/**
+ * Flaky requires a NONDETERMINISM signal: a within-run retry, or a cache key
+ * that both failed and succeeded. Failures alone — each on its own key — are
+ * legitimate breaks, however many there are.
+ *
+ * The `failures > 0` short-circuit keeps the key-count query off the common
+ * path: a task that never failed is stable without touching the DB.
+ */
+export function classifyFailureMode(
+  db: Database,
+  project: string,
+  task: string,
+  counts: { total: number; failures: number; retried: number },
+): FailureMode {
+  const flakySignal =
+    counts.retried > 0 || (counts.failures > 0 && mixedOutcomeKeyCount(db, project, task) > 0)
+  if (!flakySignal) return 'stable'
+  return counts.failures < counts.total / 5 ? 'flaky-recoverable' : 'flaky-fatal'
+}

package/src/orchestrator/framed-output.ts

@@ -60,6 +60,14 @@ export interface TaskBlockBody {
   stdout?: string
   /** stderr chunks. Renders under `├─ stderr`. */
   stderr?: string
+  /**
+   * Characters the capture dropped from the head of each stream. Non-zero
+   * only for a task whose output is bounded (a persistent one — nothing
+   * else can outrun its own exit), and rendered so a capped log can never
+   * read as a complete one.
+   */
+  droppedStdout?: number
+  droppedStderr?: number
 }
 
 export function formatTaskBlock(
@@ -84,16 +92,7 @@ export function formatTaskBlock(
 
   const idPainted = paintTaskId(node, colors, { bold: true })
   const corner = (s: string) => paint('', s, colors, { dim: true })
-  // Section labels are bold + state-colored (owner design): stdout
-  // green, stderr red, sandbox yellow, command plain white — only
-  // the command CONTENT is greyed (context, not signal). A dim rule
-  // trails each label to the frame width, and sections get vertical
-  // margins so content stands clear of the furniture.
-  const section = (title: string, color?: string) => {
-    const label = paint(color ?? '', title, colors, { bold: true })
-    const rule = corner('\u2500'.repeat(Math.max(1, FRAME_WIDTH - 4 - title.length)))
-    return `${corner('\u251c\u2500')} ${label} ${rule}`
-  }
+  const section = (title: string, color?: string) => sectionLine(title, color ?? '', colors)
   const header = formatBlockHeader(outcome, colors)
   const lines: string[] = [`${corner('┌─')} ${idPainted} ${corner('>')} ${header}`]
 
@@ -107,17 +106,8 @@ export function formatTaskBlock(
     lines.push('', corner(`$ ${node.config.exec?.command ?? ''}`), '')
   }
 
-  if (stdout.trim().length > 0) {
-    lines.push(section('STDOUT', SUCCESS), '')
-    pushBodyLines(lines, stdout)
-    lines.push('')
-  }
-
-  if (stderr.trim().length > 0) {
-    lines.push(section('STDERR', ERROR), '')
-    pushBodyLines(lines, stderr)
-    lines.push('')
-  }
+  pushStreamSection(lines, stdout, 'STDOUT', SUCCESS, body.droppedStdout ?? 0, colors)
+  pushStreamSection(lines, stderr, 'STDERR', ERROR, body.droppedStderr ?? 0, colors)
 
   // Sandbox violations get a dedicated section inside the frame so the
   // user sees them in context with the failing task, not as loose
@@ -133,6 +123,42 @@ export function formatTaskBlock(
   return lines.join('\n') + '\n'
 }
 
+/**
+ * One `├─ <LABEL>` section of captured output, with the head-dropped notice
+ * when the capture was bounded. Shared by the task frame and the persistent
+ * tail block so the two renderings of the same bytes cannot drift.
+ */
+function pushStreamSection(
+  lines: string[],
+  text: string,
+  title: string,
+  color: string,
+  lost: number,
+  colors: ColorSupport,
+): void {
+  if (text.trim().length === 0) return
+  lines.push(sectionLine(title, color, colors), '')
+  if (lost > 0) {
+    lines.push(paint('', `… ${lost} earlier characters dropped`, colors, { dim: true }))
+  }
+  pushBodyLines(lines, text)
+  lines.push('')
+}
+
+/**
+ * Section labels are bold + state-colored (owner design): stdout green,
+ * stderr red, sandbox yellow, command plain white — only the command
+ * CONTENT is greyed (context, not signal). A dim rule trails each label to
+ * the frame width, and sections get vertical margins so content stands
+ * clear of the furniture.
+ */
+function sectionLine(title: string, color: string, colors: ColorSupport): string {
+  const corner = (s: string) => paint('', s, colors, { dim: true })
+  const label = paint(color, title, colors, { bold: true })
+  const rule = corner('─'.repeat(Math.max(1, FRAME_WIDTH - 4 - title.length)))
+  return `${corner('├─')} ${label} ${rule}`
+}
+
 /**
  * Append each line of `text` raw. Content carries no border/indent so
  * terminal wrapping never collides with frame glyphs and copy/paste
@@ -143,7 +169,7 @@ function pushBodyLines(lines: string[], text: string): void {
 }
 
 /** Stable per-project hue: FNV-style fold of the name into the palette. */
-export function projectColor(projectName: string): string {
+function projectColor(projectName: string): string {
   let h = 0
   for (let i = 0; i < projectName.length; i++) {
     h = (h * 31 + projectName.charCodeAt(i)) >>> 0
@@ -172,7 +198,7 @@ export function paintIdParts(
   )
 }
 
-export function paintId(
+function paintId(
   projectName: string,
   taskName: string,
   colors: ColorSupport,
@@ -181,11 +207,7 @@ export function paintId(
   return paintIdParts(projectName, projectName, taskName, colors, opts)
 }
 
-export function paintTaskId(
-  node: TaskNode,
-  colors: ColorSupport,
-  opts: { bold?: boolean } = {},
-): string {
+function paintTaskId(node: TaskNode, colors: ColorSupport, opts: { bold?: boolean } = {}): string {
   return paintId(node.projectName, node.taskName, colors, opts)
 }
 
@@ -197,8 +219,8 @@ export function paintTaskId(
 // fixed cell so durations line up and a ticking elapsed never shifts
 // the row. All detail (exit code, output) lives in the framed block.
 export const TIME_COL = 7 // "0ms" … "999.99s"
-export const STATUS_COL = 7 // "success" / "running" / "skipped"
-export const CACHE_COL = 6 // "remote" / "local" / "fresh" / "miss"
+const STATUS_COL = 7 // "success" / "running" / "skipped"
+const CACHE_COL = 6 // "remote" / "local" / "fresh" / "miss"
 
 /** Right-align the duration in a TIME_COL cell (pad on the left). */
 function timeCell(ms: number | null, colors: ColorSupport): string {
@@ -271,7 +293,7 @@ function cacheOf(o: TaskOutcome): { word: string; color: string } {
 }
 
 /** The painted status glyph (shape = cache axis, color = task axis). */
-export function taskGlyph(o: TaskOutcome, colors: ColorSupport): string {
+function taskGlyph(o: TaskOutcome, colors: ColorSupport): string {
   return paint(statusOf(o).color, glyphShape(o), colors)
 }
 
@@ -385,6 +407,33 @@ function isPersistentNode(node: TaskNode): boolean {
   return node.config.exec?.persistent !== undefined
 }
 
+/**
+ * Everything a persistent task wrote AFTER it signalled ready, as one
+ * trailing block. Its outcome landed at ready while the child kept
+ * running, so this uses the live frame's `▸ … running` vocabulary rather
+ * than the success frame `formatTaskBlock` renders — the block is a tail,
+ * not a completed task's log. Section titles say `(since ready)` because
+ * the pre-ready output already went out with the outcome, and a
+ * head-dropped tail names how much it lost so a truncated log can never
+ * read as complete. Empty body → '' (the caller writes nothing).
+ */
+export function formatPersistentTailBlock(
+  node: TaskNode,
+  outcome: TaskOutcome,
+  body: TaskBlockBody,
+  dropped: { stdout?: number; stderr?: number } = {},
+  colors: ColorSupport = NO_COLOR,
+): string {
+  const stdout = body.stdout ?? ''
+  const stderr = body.stderr ?? ''
+  if (stdout.trim().length === 0 && stderr.trim().length === 0) return ''
+  const lines: string[] = [formatFrameOpen(node, colors)]
+  pushStreamSection(lines, stdout, 'STDOUT (since ready)', SUCCESS, dropped.stdout ?? 0, colors)
+  pushStreamSection(lines, stderr, 'STDERR (since ready)', ERROR, dropped.stderr ?? 0, colors)
+  lines.push(formatFrameClose(node, outcome, colors))
+  return lines.join('\n') + '\n'
+}
+
 /**
  * Between the requested task's frame and the summary footer, list the
  * persistent tasks (dev servers / watchers) the run is keeping alive in
@@ -430,10 +479,13 @@ function formatBlockHeader(o: TaskOutcome, colors: ColorSupport): string {
 }
 
 function formatBlockFooter(o: TaskOutcome, colors: ColorSupport): string {
-  // Footer pattern: ` (<dur>) <status>`. Duration is always shown.
-  // For cache hits it's the *original* exec time the entry was
-  // stored with (set by execute-task), not the ~0ms replay cost.
-  // Status differs by outcome — see formatStatusTag.
+  // Footer pattern: ` (<dur>) <status>`. Duration is always shown, and it is
+  // always what THIS run spent — for a cache hit, the probe + restore, not
+  // the exec time the entry was stored with. (The comment here used to claim
+  // the opposite; the code never did, and `--report` summed these as "time
+  // saved" on the strength of it. The stored time lives on
+  // `TaskOutcome.storedDurationMs`.) Status differs by outcome — see
+  // formatStatusTag.
   const dur = paint('', `(${formatDuration(o.durationMs)})`, colors, { dim: true })
   const tag = formatStatusTag(o, colors)
   return ` ${dur} ${tag}`

package/src/orchestrator/history.ts

@@ -12,6 +12,9 @@
 //                            when such an RPC actually exists.
 
 import type { Database } from 'bun:sqlite'
+import { EXECUTED_RUNS_SQL } from '../cache/index.js'
+import { classifyFailureMode } from './failure-mode.js'
+import type { FailureMode } from './failure-mode.js'
 
 const DEFAULT_RECENT = 50
 
@@ -27,8 +30,9 @@ export interface TaskHistory {
   successRate: number
   /** Cache hit rate over the recent window ([0, 1]). */
   hitRate: number
-  /** Failure mode classification. */
-  failureMode: 'stable' | 'flaky-recoverable' | 'flaky-fatal'
+  /** Failure mode classification. Shares `classifyFailureMode` with
+   *  the run-history readers so the two surfaces cannot disagree. */
+  failureMode: FailureMode
 }
 
 /** Map keyed by `project#task`. */
@@ -56,11 +60,26 @@ export class LocalHistoryProvider implements HistoryProvider {
     const out = new Map<string, TaskHistory>()
     if (taskIds.length === 0) return out
 
+    // Split `project#task` into (project, task) pairs so the WHERE filters on a
+    // ROW-VALUE `IN (VALUES …)` the `runs(project, task)` index can SEARCH
+    // (seek) — filtering on the concatenated `project || '#' || task`
+    // expression forced a full index SCAN instead. Split on the FIRST `#`:
+    // task names never contain `#`, and a project name (a package name) never
+    // does either.
+    const pairs = (taskIds as string[]).map(splitTaskId)
+    const tupleParams = pairs.flat()
+    const tuplePlaceholders = pairs.map(() => '(?,?)').join(',')
+
     // One CTE per call: rank rows per (project, task) descending by
     // started_at, keep the top `recent`, aggregate. Cache-hit rows
     // (cache_hit = 1) are excluded from the duration percentiles so
     // p50/p99 reflect work the runner actually did. successRate +
     // hitRate are computed over ALL recent rows.
+    //
+    // `skipped` rows are excluded from the window entirely: a skip is a task
+    // the run never executed, so it neither belongs in a success/hit RATE nor
+    // deserves to occupy one of the `recent` slots — a task whose upstream
+    // keeps breaking would otherwise push its own real history out of view.
     const sql = `
       WITH recent AS (
         SELECT
@@ -69,9 +88,11 @@ export class LocalHistoryProvider implements HistoryProvider {
           status,
           duration_ms,
           cache_hit,
+          attempts,
           ROW_NUMBER() OVER (PARTITION BY project, task ORDER BY started_at DESC) AS rn
         FROM runs
-        WHERE (project || '#' || task) IN (${taskIds.map(() => '?').join(',')})
+        WHERE (project, task) IN (VALUES ${tuplePlaceholders})
+          AND ${EXECUTED_RUNS_SQL}
       )
       SELECT
         project,
@@ -80,7 +101,8 @@ export class LocalHistoryProvider implements HistoryProvider {
         SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) AS successes,
         SUM(CASE WHEN cache_hit = 1 THEN 1 ELSE 0 END) AS hits,
         SUM(CASE WHEN cache_hit IS NULL OR cache_hit = 0 THEN 1 ELSE 0 END) AS executed,
-        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failures
+        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failures,
+        SUM(CASE WHEN attempts > 1 THEN 1 ELSE 0 END) AS retried
       FROM recent
       WHERE rn <= ${this.recent}
       GROUP BY project, task
@@ -94,20 +116,30 @@ export class LocalHistoryProvider implements HistoryProvider {
       hits: number
       executed: number
       failures: number
+      retried: number
     }
-    const rows = this.db.query(sql).all(...(taskIds as string[])) as Row[]
+    const rows = this.db.query(sql).all(...tupleParams) as Row[]
+
+    // Percentiles need a row-wise read (percentile_cont isn't in SQLite), but
+    // ONE windowed query pulls the last `recent` EXECUTED+SUCCESS durations for
+    // EVERY task at once — the old per-task `percentilesFor` was an N+1 (one
+    // query per task on top of the counts CTE). Same per-task window (last
+    // `recent` executed-success rows by started_at DESC), grouped in JS.
+    const durationsByTask = this.durationsFor(taskIds)
 
     for (const row of rows) {
       const key = `${row.project}#${row.task}`
       const total = row.total || 0
-      const failures = row.failures || 0
-      const failureMode: TaskHistory['failureMode'] =
-        failures === 0 ? 'stable' : failures < total / 5 ? 'flaky-recoverable' : 'flaky-fatal'
-      const { p50, p99 } = this.percentilesFor(row.project, row.task)
+      const failureMode = classifyFailureMode(this.db, row.project, row.task, {
+        total,
+        failures: row.failures || 0,
+        retried: row.retried || 0,
+      })
+      const durations = durationsByTask.get(key)
       out.set(key, {
         runs: total,
-        p50DurationMs: p50,
-        p99DurationMs: p99,
+        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,
         failureMode,
@@ -116,31 +148,46 @@ export class LocalHistoryProvider implements HistoryProvider {
     return out
   }
 
-  // Percentiles need a row-wise read; do it in JS rather than try to
-  // express the percentile_cont equivalent in SQLite. Tiny rows.
-  private percentilesFor(
-    project: string,
-    task: string,
-  ): { p50: number | undefined; p99: number | undefined } {
-    const rows = this.db
-      .query(
-        `SELECT duration_ms FROM runs
-         WHERE project = ? AND task = ?
-           AND (cache_hit IS NULL OR cache_hit = 0)
-           AND status = 'success'
-         ORDER BY started_at DESC
-         LIMIT ?`,
+  /**
+   * The last `recent` executed-success `duration_ms` values per `project#task`,
+   * ASCENDING (ready for percentile picking), in ONE windowed query for the
+   * whole task set. A `project#task` with no executed-success rows is absent.
+   */
+  private durationsFor(taskIds: readonly string[]): Map<string, number[]> {
+    const pairs = (taskIds as string[]).map(splitTaskId)
+    const sql = `
+      SELECT project, task, duration_ms FROM (
+        SELECT project, task, duration_ms,
+          ROW_NUMBER() OVER (PARTITION BY project, task ORDER BY started_at DESC) AS rn
+        FROM runs
+        WHERE (project, task) IN (VALUES ${pairs.map(() => '(?,?)').join(',')})
+          AND (cache_hit IS NULL OR cache_hit = 0)
+          AND status = 'success'
       )
-      .all(project, task, this.recent) as { duration_ms: number }[]
-    if (rows.length === 0) return { p50: undefined, p99: undefined }
-    const durations = rows.map((r) => r.duration_ms).sort((a, b) => a - b)
-    return {
-      p50: pickPercentile(durations, 0.5),
-      p99: pickPercentile(durations, 0.99),
+      WHERE rn <= ${this.recent}`
+    const rows = this.db.query(sql).all(...pairs.flat()) as {
+      project: string
+      task: string
+      duration_ms: number
+    }[]
+    const out = new Map<string, number[]>()
+    for (const r of rows) {
+      const key = `${r.project}#${r.task}`
+      const list = out.get(key)
+      if (list) list.push(r.duration_ms)
+      else out.set(key, [r.duration_ms])
     }
+    for (const list of out.values()) list.sort((a, b) => a - b)
+    return out
   }
 }
 
+/** Split a `project#task` id on its FIRST `#` (task names contain no `#`). */
+function splitTaskId(id: string): [string, string] {
+  const i = id.indexOf('#')
+  return i < 0 ? [id, ''] : [id.slice(0, i), id.slice(i + 1)]
+}
+
 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))

package/src/orchestrator/index.ts

@@ -11,7 +11,8 @@ export type { RunOptions, RunSummary } from './options.js'
 export { type CachePolicy, FULL_CACHE_POLICY, parseCachePolicy } from '../cache/index.js'
 export { defaultLogger, resolveOutputView } from './logger.js'
 export type { Logger, OutputView } from './logger.js'
-export type { RunPlan, PlannedTask, CacheStatus } from './plan.js'
+export type { RunPlan, PlannedTask, PlanPrediction, CacheStatus } from './plan.js'
+export { formatDuration } from './summary.js'
 export {
   createEventBus,
   wireForwarder,
@@ -27,39 +28,7 @@ export type {
   TaskView,
   OutcomeView,
 } from './events.js'
-export { createVxSurface } from './devframe-surface.js'
-export { createWireRenderer } from './wire-render.js'
-export { optionsToRequest, requestToOptions } from './protocol.js'
-export type { ClientMessage, RunBackend, RunRequest, RunResult, ServerMessage } from './protocol.js'
-export { formatRunReportMarkdown } from './run-report.js'
-export {
-  clientMessageToEnvelope,
-  decodeEnvelope,
-  encodeForNDJSON,
-  encodeForSSE,
-  encodeForWS,
-  ENVELOPE_ERRORS,
-  envelopeToClientMessage,
-  envelopeToServerMessage,
-  isEnvelope,
-  isNotification,
-  isRequest,
-  makeError,
-  makeNotification,
-  makeRequest,
-  makeResponse,
-  serverMessageToEnvelope,
-  WIRE_CHANNELS,
-  WIRE_PROTOCOL_VERSION,
-} from './wire.js'
-export type {
-  Envelope,
-  ErrorResponse,
-  Notification,
-  Request as WireRequest,
-  Response as WireResponse,
-  WireChannel,
-} from './wire.js'
+export { escapeMarkdownCell, formatRunReportMarkdown, type RunResult } from './run-report.js'
 export {
   EmptyHistoryProvider,
   type HistoryProvider,
@@ -67,13 +36,17 @@ export {
   LocalHistoryProvider,
   type TaskHistory,
 } from './history.js'
-export { computePredictedPriorities } from './predict.js'
 export {
   installPlugins,
-  type BackendContext,
   type CacheContext,
-  type EventSink,
-  type EventSinkContext,
+  type ExecutorContext,
+  type CommandContext,
+  type GraphHookContext,
+  type KeyHookContext,
+  type PluginCommand,
+  type ProjectHookContext,
+  type ScheduleHookContext,
+  type WorkspaceHookContext,
   type InstallPluginsArgs,
   type Plugin,
   type PluginContext,
@@ -82,9 +55,31 @@ export {
   type PluginSetupContext,
   type VxPlugin,
 } from './plugin.js'
-export { resolveBackend, resolveCache, subscribeEventSinks } from './plugin-host.js'
+export {
+  applyConfigHooks,
+  applyGraphHooks,
+  applyKeyHooks,
+  applyProjectHooks,
+  applyScheduleHooks,
+  hasHook,
+  resolveCache,
+  resolveExecutors,
+} from './plugin-host.js'
+export { MISSING_PLUGIN_HINT } from './missing-plugin.js'
 export { subscribeTelemetry, type TelemetryHandle } from './telemetry-host.js'
-export { createTelemetrySource, deriveCacheSource, TELEMETRY_SCHEMA_VERSION } from './telemetry.js'
+// The bounded log-capture buffer every telemetry sink shares — see the
+// module header for why one implementation, not one per sink.
+export { LOG_WIRE_VERSION, TaskLogBuffer } from './task-log-buffer.js'
+export type { TaskLogBundle, TaskLogEntry } from './task-log-buffer.js'
+export {
+  assembleRunSummary,
+  createTelemetrySource,
+  deriveCacheSource,
+  isCacheHit,
+  isPassStatus,
+  TASK_STATUSES,
+  TELEMETRY_SCHEMA_VERSION,
+} from './telemetry.js'
 export type {
   CacheSource,
   RunContextRecord,
@@ -100,75 +95,33 @@ export type {
 export { diffOutputTrees } from './verify.js'
 export { deriveStableKeys } from './stable-keys.js'
 export type { DeriveStableKeysArgs, StableKey } from './stable-keys.js'
-export { captureGitContext, captureWorkspaceIdentity, resolveCacheScope } from './run-context.js'
-export type { GitContext, WorkspaceIdentity } from './run-context.js'
+export {
+  captureDefaultBranch,
+  captureGitContext,
+  captureHostContext,
+  captureWorkspaceIdentity,
+  detectCi,
+} from './run-context.js'
+export type { CiContext, GitContext, HostContext, WorkspaceIdentity } from './run-context.js'
 export {
   cacheKeyDiff,
-  compareRuns,
   explainCacheKey as explainCacheKeyQuery,
-  getBottlenecks,
-  getCacheBreakdown,
-  getCacheSavings,
-  getCacheStatsSql,
-  getFlakiestTasks,
-  getHistory,
-  getHitRateSplit,
   getInvocation,
-  getParallelismHistory,
-  getPeriodComparison,
-  getPrunableEntries,
-  getRecentFailures,
-  getRegressions,
   getRun,
-  getRunHeatmap,
-  getRunTrends,
-  getStorageGrowth,
-  getTaskDetail,
-  getTopTimeBurners,
-  listCacheEntries,
   listInvocations,
-  listProjects,
   listRuns,
   whyDidThisRerun as whyDidThisRerunQuery,
 } from './metrics.js'
 export type {
-  BottleneckRow,
   CacheEntryRow,
   CacheKeyDiff,
   CacheKeyExplanation,
-  CacheProjectRow,
-  CacheSavings,
-  CacheStatsResult,
-  CompareRuns,
-  CompareTaskRow,
-  CompareTaskSide,
-  FailureRow,
-  FlakyTask,
-  GetHistoryArgs,
-  HeatmapCell,
-  HitRateSplit,
   InputDiffEntry,
   InvocationDetail,
   InvocationRow,
-  ListCacheEntriesArgs,
   ListInvocationsArgs,
   ListRunsArgs,
-  ParallelismPoint,
-  PeriodComparison,
-  PeriodComparisonArgs,
-  PeriodStats,
-  PrunableEntry,
-  ProjectRollup,
-  RegressedTask,
-  RegressionArgs,
-  TaskMover,
   RunDetail,
   RunSummaryRow,
-  StoragePoint,
-  TaskDetail,
-  TaskHistoryRow,
-  TopTaskRow,
-  TrendBucket,
-  TrendPoint,
   WhyDidThisRerun,
 } from './metrics.js'

package/src/orchestrator/local-shortcircuit.ts

@@ -38,6 +38,7 @@
 //     conservative exclusion). Those tasks still get an exec-tier probe
 //     reuse entry so there's no double work.
 
+import { span } from '../util/index.js'
 import type { CacheEntry, CacheLayer, GitFilesCache } from '../cache/index.js'
 import type { TaskNode } from '../graph/index.js'
 import { deriveStableKeys } from './stable-keys.js'
@@ -95,10 +96,13 @@ const EMPTY: ShortCircuit = { preProbed: new Map(), restoreTier: new Set() }
  */
 export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<ShortCircuit> {
   let stableKeys
+  const endKeys = span('stable keys')
   try {
     stableKeys = await deriveStableKeys(args)
   } catch {
     return EMPTY
+  } finally {
+    endKeys()
   }
   const candidates = stableKeys.filter(({ node }) => node.config.cache !== undefined)
   if (candidates.length === 0) return EMPTY
@@ -125,6 +129,24 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
   // it); a miss stays exec-tier with a known-miss reuse entry. The pool
   // keeps the up-front pass from being a serial pre-phase on a wide warm
   // graph — the probes parallelize at the run's concurrency.
+  // A layer with a batched `get` answers every probe in a couple of
+  // queries; the pool below is for layers without one.
+  if (args.cache.getMany !== undefined) {
+    try {
+      const endProbe = span('probe')
+      const hits = await args.cache.getMany(candidates.map((c) => c.hash))
+      endProbe()
+      for (const { hash, node } of candidates) {
+        const hit = hits.get(hash) ?? null
+        preProbed.set(node.id, { hash, hit })
+        if (hit !== null && !anyWorkspaceOutputs) restoreTier.add(node.id)
+      }
+      return { preProbed, restoreTier }
+    } catch {
+      // Fall through to the per-hash pool, which isolates a failing probe
+      // to its own task.
+    }
+  }
   let next = 0
   const workers = Math.max(1, Math.min(args.concurrency, candidates.length))
   const pump = async (): Promise<void> => {