@vzn/vx 0.0.637 → 0.0.638

package/src/graph/task-graph.ts

@@ -7,6 +7,7 @@ import {
   splitNegations,
   staticPrefix,
   taskGlob,
+  refusal,
   UserError,
   wholeSubtreePrefixes,
 } from '../util/index.js'
@@ -969,6 +970,19 @@ function witnessed(a: string, b: string): boolean {
       if (ga.match(candidate) && gb.match(candidate)) return true
     }
   }
+  // Each glob filled in whole, every wildcard a name and `**` one level or
+  // none: `**/dist/**` beside `**/*` meets at `x/dist/x`, a path neither
+  // last segment builds (solid, M 2026-10-15).
+  for (const glob of [a, b]) {
+    const segs = glob.split('/')
+    if (segs.some((s) => /[[\]{}()!+@]/.test(s))) continue
+    for (const drop of [false, true]) {
+      const candidate = segs
+        .flatMap((s) => (s === '**' ? (drop ? [] : ['x']) : [s.replace(/\*+|\?/g, 'x')]))
+        .join('/')
+      if (candidate !== '' && ga.match(candidate) && gb.match(candidate)) return true
+    }
+  }
   return false
 }
 
@@ -1407,8 +1421,19 @@ function collide(
       // `run.rules.exclusiveOutputs` is off (X-53). Without an edge the two run
       // in either order, and the refusal below stands.
       const [up, down] = reaches(b.id, a.id) ? [a, b] : reaches(a.id, b.id) ? [b, a] : []
+      const parts = {
+        headline: `${a.id} and ${b.id} both write ${ga === gb ? ga : `${ga} / ${gb}`}`,
+        ...(field === 'files' ? {} : { what: ['in cache.outputs.workspaceFiles'] }),
+        why: "vx clears a task's outputs before it runs, so one deletes the other's",
+      }
       if (up !== undefined && exclusive)
-        throw new UserError(`${head}. ${EXCLUSIVE_OUTPUTS_FIX}`, 'VX_E_OUTPUT_OVERLAP')
+        throw refusal(
+          {
+            ...parts,
+            fix: 'give each task its own output path, or set run.rules.exclusiveOutputs: false in .vx/workspace.ts',
+          },
+          { code: 'VX_E_OUTPUT_OVERLAP', message: `${head}. ${EXCLUSIVE_OUTPUTS_FIX}` },
+        )
       if (up !== undefined && down !== undefined) {
         const downGlobs = splitNegations(
           (field === 'files'
@@ -1419,9 +1444,12 @@ function collide(
         ;(up.outputsAddedToBy ??= []).push(...(downGlobs ?? []))
         return
       }
-      throw new UserError(
-        `${head} and the run still reports success. Give each task its own output path.`,
-        'VX_E_OUTPUT_OVERLAP',
+      throw refusal(
+        { ...parts, fix: 'give each task its own output path' },
+        {
+          code: 'VX_E_OUTPUT_OVERLAP',
+          message: `${head} and the run still reports success. Give each task its own output path.`,
+        },
       )
     }
   }

package/src/index.ts

@@ -89,7 +89,13 @@ export type { TaskNode, TaskOutcome, TaskStatus } from './graph/index.js'
 
 // Cache classes + the layer interface (the `cache` capability's currency).
 export { Cache } from './cache/index.js'
-export type { CacheLayer, RemoteCacheLayer, RunRecord, InvocationRecord } from './cache/index.js'
+export type {
+  CacheLayer,
+  PluginCache,
+  RemoteCacheLayer,
+  RunRecord,
+  InvocationRecord,
+} from './cache/index.js'
 
 // Workspace discovery + the project/config catalog surface — an
 // out-of-process service/CLI needs these. `loadProjectConfig` is the RAW
@@ -118,6 +124,8 @@ export {
   quoteTsLiteral,
   taskNameProblem,
 } from './workspace/index.js'
+// Output components: a plugin draws its lines with core's, so they look alike.
+export { ui } from './util/index.js'
 export type {
   ApplyMigrationArgs,
   MigrationFormat,
@@ -166,6 +174,8 @@ export type {
   DiscoverContext,
   DiscoveredProject,
   PluginSetupContext,
+  RunReport,
+  RunReportTask,
   PluginHookName,
   PluginHookHandlers,
   RunStartInfo,

package/src/orchestrator/affected-tasks.ts

@@ -62,13 +62,15 @@ function wholeProjects(
  * `input`, a changed `file` is one of its declared inputs; `project`, its
  * project changed and the task reads it whole (an uncached task, a path no
  * cached task declares, or no single `file`: a lockfile claim, a manifest
- * edge, a config import); `package`, a `^` edge passes through `project`, a
+ * edge, a config import); `workspace`, a workspace-wide `file` (the
+ * workspace config, a root file a plugin claims) reached every task of its
+ * project; `package`, a `^` edge passes through `project`, a
  * changed package with no such task; `named`, asked as `pkg#task`;
  * `selected`, another filter selected its project outright. `via` is the
  * `dependsOn` chain, nearest first, to the task the change seeded.
  */
 export interface AffectedReason {
-  kind: 'input' | 'project' | 'package' | 'named' | 'selected'
+  kind: 'input' | 'project' | 'workspace' | 'package' | 'named' | 'selected'
   /** Workspace-relative. */
   file?: string
   project?: string
@@ -102,7 +104,10 @@ export function affectedRoots(
   const seeds = explain === undefined ? null : new Map<string, AffectedReason>()
   const through = explain === undefined ? null : new Map<string, string>()
   const inProject = (name: string, rel: string | undefined): AffectedReason => {
-    if (rel === undefined) return { kind: 'project' }
+    if (rel === undefined) {
+      const file = changes.wholeBy?.get(name)
+      return file === undefined ? { kind: 'project' } : { kind: 'workspace', file }
+    }
     const dir = path.relative(explain!.workspaceRoot, projects.get(name)!.dir)
     return { kind: 'project', file: dir === '' ? rel : path.posix.join(dir, rel) }
   }

package/src/orchestrator/doctor.ts

@@ -384,7 +384,7 @@ function gitVersion(): string | null {
 function settingsFact(config: WorkspaceConfig | null): InfoFacts['settings'] {
   const out: InfoFacts['settings'] = {}
   for (const s of SETTINGS) {
-    const env = process.env[envName(s.path)]
+    const env = s.env === false ? undefined : process.env[envName(s.path)]
     const declared = s.config === false ? undefined : atPath(config, s.path)
     out[s.path] =
       env !== undefined && env !== ''

package/src/orchestrator/execute-task.ts

@@ -5,7 +5,6 @@ import {
   type CacheEntry,
   type CacheLayer,
   type CachePolicy,
-  anyUntouched,
   cleanOutputs,
   committedFiles,
   cleanWorkspaceOutputs,
@@ -189,7 +188,7 @@ export interface ExecuteArgs {
    * the env vars (above the task), `workspace` from `.vx/workspace` (below).
    */
   inputStability?: { run: InputStability; workspace?: InputStability }
-  /** `cache.outputs.clean` for tasks without their own: its variable, else `.vx/workspace`. */
+  /** `cache.outputs.clean` for tasks without their own: `.vx/workspace`. */
   cleanOutputs?: boolean
   /** Per-run memo for `git ls-files` (one entry per project dir). */
   gitFilesCache?: GitFilesCache
@@ -257,6 +256,12 @@ export interface ExecuteArgs {
    * clean run's stale hit.
    */
   taintedUpstream?: boolean
+  /**
+   * The run keeps its bytes in a remote (run-store.ts): an attempt captures
+   * its output at the entry's bounds, and an outcome that saves no entry
+   * (a failure, an uncached run) carries it as `runLog`.
+   */
+  keepRunLog?: boolean
   /**
    * Whether a task has rewritten a root file a plugin claims (whose bytes
    * the claimant folded) since the run read it (fingerprint-watch.ts): past that, no key taken
@@ -977,11 +982,11 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   let stampedBefore: ReadonlyMap<string, OutputStamp> | undefined
   let wsStampedBefore: ReadonlyMap<string, OutputStamp> | undefined
   // `cache.outputs.clean: false` leaves the outputs to the first attempt's
-  // command, stamped, so a save can tell what it found and never wrote.
-  // An additive task never cleans by glob anyway.
+  // command, and the save stores whatever they hold after it, a leftover
+  // included: the user opted out of the clean-tree guarantee (M,
+  // 2026-10-15). A retry still starts clean. An additive task never cleans
+  // by glob anyway.
   const keepOutputs = !additive && (cacheCfg?.outputs.clean ?? args.cleanOutputs ?? true) === false
-  let keptBefore: ReadonlyMap<string, OutputStamp> | undefined
-  let wsKeptBefore: ReadonlyMap<string, OutputStamp> | undefined
 
   // Cache lookup. On hit, time the user-perceived restore op
   // (clean+restore+log-replay) — that's what the framed-block footer
@@ -1148,6 +1153,8 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     exitCode: number
     withdrawn?: true
   }> {
+    // The first attempt under `clean: false` finds its last outputs (tsc's `.tsbuildinfo`).
+    const clean = willWrite && !deferralRequested && !(keepOutputs && attempt === 1)
     // A deferred task's outputs are deliberately NOT coming, so wiping the
     // tree would replace a stale build with nothing at all. The eligibility
     // gate guarantees no key in this run can see what stays behind, and the
@@ -1156,16 +1163,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       const endStamp = span('miss: stamp outputs')
       stampedBefore ??= await stampOutputs(cleanArgs)
       endStamp()
-    } else if (
-      keepOutputs &&
-      attempt === 1 &&
-      willWrite &&
-      !deferralRequested &&
-      outputs.length > 0
-    ) {
-      keptBefore = await stampOutputs(cleanArgs)
-    } else if (willWrite && !deferralRequested && outputs.length > 0) {
-      keptBefore = undefined
+    } else if (clean && outputs.length > 0) {
       // Mark the wiped paths, exactly as the workspace twin below does. The
       // git snapshot still lists them with their committed index OIDs, and
       // resolveFiles SKIPS its existence probe for any path carrying a
@@ -1182,16 +1180,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       // glob clean deleted the upstream's files before this task, which
       // reads them, ran (A-43).
       wsStampedBefore ??= await stampWorkspaceOutputs(wsCleanArgs)
-    } else if (
-      keepOutputs &&
-      attempt === 1 &&
-      willWrite &&
-      !deferralRequested &&
-      wsOutputs.length > 0
-    ) {
-      wsKeptBefore = await stampWorkspaceOutputs(wsCleanArgs)
-    } else if (willWrite && !deferralRequested && wsOutputs.length > 0) {
-      wsKeptBefore = undefined
+    } else if (clean && wsOutputs.length > 0) {
       // Root-anchored deletions can land in other projects' dirs; mark
       // them so stale per-project git snapshots can't survive the wipe.
       const cleanedWsRels = await cleanWorkspaceOutputs(wsCleanArgs)
@@ -1481,9 +1470,10 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   }
 
   async function buildRequest(local: boolean): Promise<ExecuteRequest> {
-    const kept = willSave
-      ? new BoundedCapture()
-      : new BoundedCapture(FAILED_OUTPUT_HEAD_CHARS, FAILED_OUTPUT_TAIL_CHARS)
+    const kept =
+      willSave || args.keepRunLog === true
+        ? new BoundedCapture()
+        : new BoundedCapture(FAILED_OUTPUT_HEAD_CHARS, FAILED_OUTPUT_TAIL_CHARS)
     output = kept
     const toOut = (t: string): void => {
       kept.push(t)
@@ -1553,6 +1543,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const stability = inputStabilityOf(args.node.config.cache, args.inputStability)
   let movedFails: string | undefined
   let own: Awaited<ReturnType<typeof ownOutputs>>
+  let saved = false
   if (effectiveExitCode === 0 && willSave && deferralRequested) {
     // The outputs never landed here: no artifact, no rows. A partial local
     // record (a row with no artifact) is exactly the corrupt-entry shape
@@ -1580,7 +1571,6 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   } else if (
     effectiveExitCode === 0 &&
     willSave &&
-    !leftBehind() &&
     (await keyStillTrue()) &&
     (own = await ownOutputs()) !== undefined
   ) {
@@ -1617,6 +1607,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
         : {}),
     })
     args.deferredSaves?.set(node.id, landed)
+    saved = true
   } else if (cfgCacheable && !remoteOnly && !deferralRequested && args.noDependants !== true) {
     // Ran here and saves nothing — failed, a read-only policy, a tainted
     // upstream, a key that no longer held — yet it wrote what a save would
@@ -1642,18 +1633,6 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     }
   }
 
-  /**
-   * A file the kept outputs held that the run left as it was: saving would
-   * file a leftover from an older build as this run's output, so nothing is
-   * saved (`cache.outputs.clean: false`).
-   */
-  function leftBehind(): boolean {
-    return (
-      (keptBefore !== undefined && anyUntouched(keptBefore)) ||
-      (wsKeptBefore !== undefined && anyUntouched(wsKeptBefore))
-    )
-  }
-
   /**
    * What an additive run saves as its own, or undefined when it removed a
    * file it found: no entry replays a removal (`ownOutputsSince`), so the
@@ -1771,8 +1750,12 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       : {}),
     ...(inputChanges !== undefined ? { inputChanges } : {}),
     ...(unkeyed ? { unkeyed: true as const } : {}),
+    ...(saved ? { saved: true as const } : {}),
     ...(effectiveExitCode !== 0 && output !== undefined
-      ? { failedOutput: failedOutputLog(output, willSave) }
+      ? { failedOutput: failedOutputLog(output, willSave || args.keepRunLog === true) }
+      : {}),
+    ...(args.keepRunLog === true && (effectiveExitCode !== 0 || !willSave) && output !== undefined
+      ? { runLog: storedOutput() }
       : {}),
     ...(result.timedOut === true && effectiveExitCode !== 0 ? { timedOut: true as const } : {}),
     ...(movedFails !== undefined ? { inputMoved: movedFails } : {}),

package/src/orchestrator/failure-mode.ts

@@ -4,7 +4,9 @@
 // drift into opposite verdicts on identical data. Both build on
 // `mixedOutcomeKeysSql` + `failureModeOf`, so the rule cannot fork again.
 // The per-run detector (`detectFlaky`) and the doctor's list (`flakyTasks`)
-// read the same per-key projection (`keyOutcomesSql`).
+// read the same per-key projection (`keyOutcomesSql`) over the shared
+// store's flaky record (`task_outcomes`, v38), so every worktree of a repo
+// judges a key on what all of them saw.
 
 import type { Database } from 'bun:sqlite'
 import { KEYED_RUNS_SQL } from '../cache/index.js'
@@ -17,6 +19,9 @@ const HIT_STATUSES = `(${TASK_STATUSES.filter(isCacheHit)
   .map((s) => `'${s}'`)
   .join(', ')})`
 
+/** The shared store's flaky record: what `detectFlaky` and `flakyTasks` read. */
+const OUTCOMES = 'task_outcomes'
+
 export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
 
 /**
@@ -33,6 +38,10 @@ export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
  * projection.
  */
 function keyOutcomesSql(source: string, where = ''): string {
+  // The flaky record keeps only rows that observed their key (run-history.ts
+  // `observesKey`), so it carries none of the filter's columns.
+  const keyed =
+    source === OUTCOMES ? '1' : `${KEYED_RUNS_SQL} AND cached IS NOT 0 AND blocked_by IS NULL`
   return `SELECT project, task, hash, SUM(failed) AS failures, SUM(passed) AS passes,
        SUM(retried) AS retried_failures,
        SUM(CASE WHEN failed = 1 AND id > first_pass THEN 1 ELSE 0 END) AS relapses
@@ -41,10 +50,10 @@ function keyOutcomesSql(source: string, where = ''): string {
          FROM (SELECT project, task, hash, id,
              CASE WHEN status = 'failed' THEN 1 ELSE 0 END AS failed,
              CASE WHEN status = 'success' AND attempts > 1 THEN attempts - 1 ELSE 0 END AS retried,
-             CASE WHEN status = 'success' OR status IN ${HIT_STATUSES} OR cache_hit = 1
+             CASE WHEN status = 'success' OR status IN ${HIT_STATUSES}${source === OUTCOMES ? '' : ' OR cache_hit = 1'}
                THEN 1 ELSE 0 END AS passed
            FROM ${source}
-           WHERE ${KEYED_RUNS_SQL} AND cached IS NOT 0 AND blocked_by IS NULL${where}))
+           WHERE ${keyed}${where}))
        GROUP BY project, task, hash`
 }
 
@@ -136,9 +145,9 @@ const keyOf = (c: { project: string; task: string; hash: string }): string =>
  * failures is a recovery, not a flake. The counts fold this run in.
  *
  * The cost follows the run's colour. No candidate (every task a hit or a
- * skip): no query. A green miss: one probe of the `runs_failed` partial
- * index for the keys that ever failed — failures are the rare rows, so the
- * probe is microseconds however long the history. Only a key that DID fail
+ * skip): no query. A green miss: one probe of the `task_outcomes_hash`
+ * index for the keys that ever failed — a key holds a handful of rows, so
+ * the probe is microseconds however long the history. Only a key that DID fail
  * before, or a task failing now, pays the projection scan over its own
  * keys, and a run that is failing has more to look at than a scan.
  */
@@ -149,8 +158,8 @@ export function detectFlaky(db: Database, candidates: readonly FlakyCandidate[])
   chunked(passedNow, (chunk) => {
     const rows = db
       .query(
-        `SELECT DISTINCT project, task, hash FROM runs
-         WHERE status = 'failed' AND blocked_by IS NULL AND hash IN (${chunk.map(() => '?').join(', ')})`,
+        `SELECT DISTINCT project, task, hash FROM ${OUTCOMES}
+         WHERE status = 'failed' AND hash IN (${chunk.map(() => '?').join(', ')})`,
       )
       .all(...chunk.map((c) => c.hash)) as { project: string; task: string; hash: string }[]
     for (const r of rows) everFailed.add(keyOf(r))
@@ -162,7 +171,7 @@ export function detectFlaky(db: Database, candidates: readonly FlakyCandidate[])
   const counts = new Map<string, { passes: number; failures: number; relapses: number }>()
   chunked(suspects, (chunk) => {
     const rows = db
-      .query(keyOutcomesSql('runs', ` AND hash IN (${chunk.map(() => '?').join(', ')})`))
+      .query(keyOutcomesSql(OUTCOMES, ` AND hash IN (${chunk.map(() => '?').join(', ')})`))
       .all(...chunk.map((c) => c.hash)) as {
       project: string
       task: string
@@ -212,7 +221,7 @@ export function flakyTasks(db: Database): FlakyTask[] {
     .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('runs')})
+             FROM (${keyOutcomesSql(OUTCOMES)})
              WHERE relapses > 0 OR retried_failures > 0)
        GROUP BY project, task
        ORDER BY failures DESC, passes DESC, project, task`,

package/src/orchestrator/framed-output.ts

@@ -27,8 +27,7 @@
 
 import { withForwardArgs } from '../exec/index.js'
 import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
-import { formatElapsed, maskedCommand } from '../util/index.js'
-import { paint, type ColorSupport } from './colors.js'
+import { formatElapsed, maskedCommand, paint, type ColorSupport } from '../util/index.js'
 import { neverStarted } from './summary.js'
 import { outcomeLabel, ranNoCache, skippedReason } from './events.js'
 import { fileMemo, linkPaths } from './path-links.js'

package/src/orchestrator/history.ts

@@ -219,10 +219,49 @@ export class LocalHistoryProvider implements HistoryProvider {
     return this.forecasts(new Set(taskIds))
   }
 
+  /**
+   * Whether the last forecast read found some task with no timing on this
+   * branch (on any branch when the provider has none): what a
+   * default-branch import is for. Learned by the read itself, so asking
+   * costs nothing (a query per task was 70 ms at 8,002 tasks).
+   */
+  lackedBranchHistory = false
+
+  /** Whether timings of default-branch commit `sha` were imported. */
+  hasImported(sha: string): boolean {
+    return (
+      this.db
+        .query(`SELECT 1 FROM task_durations WHERE source = 'remote' AND sha = ? LIMIT 1`)
+        .get(sha) !== null
+    )
+  }
+
+  /**
+   * Keep default-branch commit `sha`'s timings (task id → ms) as forecast
+   * rows: one per task, so a repeat import, by this worktree or another
+   * at once, adds nothing.
+   */
+  importTimings(sha: string, timings: ReadonlyMap<string, number>): void {
+    const insert = this.db.query(
+      `INSERT OR IGNORE INTO task_durations(project, task, source, sha, duration_ms, recorded_at)
+       VALUES (?, ?, 'remote', ?, ?, ?)`,
+    )
+    const now = Date.now()
+    this.db
+      .transaction(() => {
+        for (const [id, ms] of timings) {
+          const [project, task] = splitTaskId(id)
+          insert.run(project, task, sha, Math.round(ms), now)
+        }
+      })
+      .immediate()
+  }
+
   /**
    * Each task's duration forecast (owner, 2026-10-14): the median of its
-   * last `FORECAST_RUNS` timings on this branch, else on any branch, else
-   * none. The timings are the shared store's `task_durations`, so every
+   * last `FORECAST_RUNS` timings on this branch, else the default branch's
+   * newest imported timing (`importTimings`), else the median on any
+   * branch, else none. The timings are the shared store's `task_durations`, so every
    * worktree of the repo reads them and a new one forecasts on its first
    * run. A point read per task on `(project, task, source, id)`: exact
    * however old the rows, where the runs window holds only the newest
@@ -230,9 +269,9 @@ export class LocalHistoryProvider implements HistoryProvider {
    */
   private forecasts(wanted: ReadonlySet<string>): Map<string, number> {
     const out = new Map<string, number>()
+    this.lackedBranchHistory = false
     if (wanted.size === 0) return out
-    // Tiers, first answer wins. The remote cache's default-branch timings
-    // (#3563) slot in between the two.
+    // Tiers, first answer wins.
     type Tier = (project: string, task: string) => Array<{ ms: number }>
     const tiers: Tier[] = []
     const newest = (where: string) =>
@@ -245,18 +284,35 @@ export class LocalHistoryProvider implements HistoryProvider {
       const q = newest('source = ?')
       tiers.push((p, t) => q.all(p, t, source) as Array<{ ms: number }>)
     }
+    // One probe on the partial index first: a store with no import costs
+    // no query per task.
+    if (
+      this.db.query(`SELECT 1 FROM task_durations WHERE source = 'remote' LIMIT 1`).get() !== null
+    ) {
+      const remote = this.db.query(
+        `SELECT duration_ms AS ms FROM task_durations WHERE project = ? AND task = ? AND source = 'remote'
+         ORDER BY id DESC LIMIT 1`,
+      )
+      tiers.push((p, t) => remote.all(p, t) as Array<{ ms: number }>)
+    }
     const any = newest(`source LIKE 'branch:%'`)
     tiers.push((p, t) => any.all(p, t) as Array<{ ms: number }>)
+    const own = this.branch !== undefined ? tiers[0] : tiers.at(-1)
+    let lacked = false
     for (const id of wanted) {
       const [project, task] = splitTaskId(id)
+      let answered: Tier | undefined
       for (const tier of tiers) {
         const rows = tier(project, task)
         if (rows.length === 0) continue
         const durations = rows.map((r) => r.ms).sort((x, y) => x - y)
         out.set(id, pickPercentile(durations, 0.5))
+        answered = tier
         break
       }
+      if (answered !== own) lacked = true
     }
+    this.lackedBranchHistory = lacked
     return out
   }
 

package/src/orchestrator/index.ts

@@ -37,7 +37,6 @@ export { forwardedSignal } from './signals.js'
 // `vx cache clean` waits for a run on the workspace before it evicts.
 export { acquireRunLock } from './run-lock.js'
 export { defaultLogger, resolveOutputView } from './logger.js'
-export { detectColors, paint, type ColorSupport } from './colors.js'
 export type { Logger, OutputView } from './logger.js'
 export type { RunPlan, PlannedTask, PlanPrediction, CacheStatus } from './plan.js'
 export {
@@ -95,6 +94,8 @@ export {
   type PluginHookHandlers,
   type PluginHookName,
   type PluginSetupContext,
+  type RunReport,
+  type RunReportTask,
   type FingerprintChange,
   type FingerprintClaim,
   type FingerprintContext,

package/src/orchestrator/logger.ts

@@ -1,6 +1,5 @@
 import type { TaskNode, TaskOutcome } from '../graph/index.js'
 import { settingEnv } from '../settings.js'
-import { detectColors, type ColorSupport } from './colors.js'
 import {
   formatFrameClose,
   formatFrameOpen,
@@ -21,7 +20,7 @@ import {
   type StatusStream,
   type WorkerSlot,
 } from './status-line.js'
-import { formatSummarySection, neverStarted, type RunContext } from './summary.js'
+import { formatSummarySection, neverStarted, ranUnsaved, type RunContext } from './summary.js'
 import { isGroupTask } from '../graph/index.js'
 import {
   appendTail,
@@ -30,6 +29,8 @@ import {
   resetTail,
   tailText,
   type Tail,
+  detectColors,
+  type ColorSupport,
 } from '../util/index.js'
 import { isCacheHit } from './telemetry.js'
 import { failedLabel, outcomeWord, ranNoCache } from './events.js'
@@ -329,6 +330,8 @@ export function defaultLogger(
   let upToDate = 0
   let restoredLocal = 0
   let restoredRemote = 0
+  let saved = 0
+  let notSaved = 0
   let skippedCount = 0
   let savedMs = 0
   // Cache-miss duration spread, accumulated incrementally (the same
@@ -445,6 +448,8 @@ export function defaultLogger(
               upToDate,
               restoredLocal,
               restoredRemote,
+              saved,
+              notSaved,
               miss: succeeded + failed - noCache,
               noCache,
               savedMs,
@@ -836,6 +841,8 @@ export function defaultLogger(
           case 'success':
             succeeded++
             if (ranNoCache(outcome)) noCache++
+            if (outcome.saved === true) saved++
+            else if (ranUnsaved(outcome)) notSaved++
             break
           case 'cache-hit':
             if (outcome.restored === false) upToDate++

package/src/orchestrator/metrics.ts

@@ -21,6 +21,10 @@ import { clampInt, MASKED, secretNamed } from '../util/index.js'
 import type { TaskInputComponent } from './task-hash.js'
 import { isPassStatus } from './telemetry.js'
 
+// A recorded `cache_policy` is the `--cache-policy` spec (`local:rw,remote:r`).
+const readsCache = (spec: string): boolean => /(?:^|,)(?:local|remote):w?r/.test(spec)
+const writesCache = (spec: string): boolean => /(?:^|,)(?:local|remote):r?w/.test(spec)
+
 // ---------------------------------------------------------------------------
 // Run listing + detail
 // ---------------------------------------------------------------------------
@@ -412,7 +416,7 @@ function unchangedKeyNote(
       p: string
     } | null
   )?.p
-  if (policy !== undefined && !policy.split(',').some((axis) => axis === 'lR' || axis === 'rR')) {
+  if (policy !== undefined && !readsCache(policy)) {
     return 'cache key unchanged — re-executed because this run did not read the cache (--force, or a --cache-policy without read)'
   }
   // `get` answers null, not undefined, for no row.
@@ -438,7 +442,7 @@ function unchangedKeyNote(
       const row = db
         .query('SELECT cache_policy AS p, failed_count AS f FROM invocations WHERE run_id = ?')
         .get(id) as { p: string; f: number } | null
-      const writes = row?.p.split(',').some((axis) => axis === 'lW' || axis === 'rW') === true
+      const writes = row !== null && writesCache(row.p)
       return writes ? (row?.f ?? 0) : 0
     }
     const before = failedWithWrites(prev.runId)
@@ -472,7 +476,7 @@ function unchangedKeyNote(
               p: string
             } | null
           )?.p
-    if (prevPolicy !== undefined && !prevPolicy.split(',').some((a) => a === 'lW' || a === 'rW')) {
+    if (prevPolicy !== undefined && !writesCache(prevPolicy)) {
       return 'cache key unchanged — the previous run on this key did not write the cache (--no-cache, or a --cache-policy without write), so there was nothing to hit'
     }
     return 'cache key unchanged — the previous run on this key executed but no entry for it is in the cache (its save failed, or it was pruned since), so there was nothing to hit'