@vzn/vx 0.0.636 → 0.0.638

package/src/orchestrator/summary.ts

@@ -4,56 +4,31 @@
 // aren't real work and would inflate "N total" misleadingly.
 
 import type { TaskOutcome } from '../graph/index.js'
-import { paint, type ColorSupport } from './colors.js'
 import { tallyOutcomes } from './tally.js'
 import { isCacheHit } from './telemetry.js'
 import { outcomeLabel, projectOutcome, ranNoCache } from './events.js'
 import { isGroupTask } from '../graph/index.js'
-import { formatElapsed } from '../util/index.js'
+import {
+  ERROR,
+  formatElapsed,
+  gradientRule,
+  paint,
+  SUCCESS,
+  WARN,
+  type ColorSupport,
+} from '../util/index.js'
 
 const NO_COLOR: ColorSupport = { enabled: false }
 
-const SUCCESS = '#22c55e'
-const WARN = '#eab308'
 // Cache provenance hues (owner): local light blue, remote dark blue —
 // yellow is skipped's color on both meters.
 const LOCAL = '#38bdf8' // sky-400
 const REMOTE = '#2563eb' // blue-600
-const ERROR = '#ef4444'
 const ABORTED = '#f97316' // orange-500: red's neighbour, not a failure
+const NOT_RUN = '#a855f7' // purple-500: stopped before it began, apart from every other state
 const ACCENT = '#06b6d4' // cyan-500: the live region's running word
 
 const BAR_WIDTH = 50
-// Brand gradient for the rule: identity violet → pink (the project /
-// task hues), faded across the dash run. Plain dashes when colors
-// are off.
-const GRADIENT_FROM = [0xa7, 0x8b, 0xfa] as const
-const GRADIENT_TO = [0xf4, 0x72, 0xb6] as const
-// Rule ends flush with the bars: 2 indent + 8 label + 2 gap + 50 cells.
-const RULE_DASHES = 57
-
-/** Total visible rule width: `\u2500 <mark> ` + dashes. Shared by summary + header. */
-function gradientRule(colors: ColorSupport, mark = 'vx'): string {
-  const head = `\u2500 `
-  const dashes = '\u2500'.repeat(Math.max(8, RULE_DASHES + 2 - mark.length))
-  if (!colors.enabled) return `${head}${mark} ${dashes}`
-  const chunks = 8
-  const per = Math.ceil(RULE_DASHES / chunks)
-  let out = ''
-  for (let i = 0; i < chunks; i++) {
-    const seg = dashes.slice(i * per, (i + 1) * per)
-    if (seg.length === 0) break
-    const f = i / (chunks - 1)
-    const hex = `#${GRADIENT_FROM.map((c, j) =>
-      Math.round(c + (GRADIENT_TO[j]! - c) * f)
-        .toString(16)
-        .padStart(2, '0'),
-    ).join('')}`
-    out += paint(hex, seg, colors)
-  }
-  return `${paint(`#${GRADIENT_FROM.map((c) => c.toString(16).padStart(2, '0')).join('')}`, head, colors)}${paint('', mark, colors, { bold: true })} ${out}`
-}
-
 /**
  * Stacked state meter: one ▰ run per bucket, proportional cells via
  * largest-remainder, every non-zero bucket guaranteed at least one
@@ -110,6 +85,10 @@ export interface SummaryStats {
   upToDate: number
   restoredLocal: number
   restoredRemote: number
+  /** Ran here and saved to the cache: the legend's `↑`. */
+  saved?: number
+  /** Ran here with a `cache` block, succeeded, and saved nothing. */
+  notSaved?: number
   /** Tasks that executed (success + failed) with a `cache` block — the misses. */
   miss: number
   /** Executed with no `cache` block: never consulted the cache, not a miss. */
@@ -137,11 +116,26 @@ export interface SummaryStats {
  */
 export interface RunContext {
   version: string
-  /** Projects covered by the graph — the "in run" half of the bar. */
+  /** Projects covered by the graph — the "affected" half of the bar. */
   packageCount: number
   /** Worker-pool size for this run; shown on the `info` row. */
   concurrency?: number
   remoteCacheEnabled: boolean
+  /**
+   * The cache layers the run used, so the legend reads `local 1= 2↓ 4↑ ·
+   * remote 3↓ 4↑`. Absent: the plain `N miss` legend.
+   */
+  cache?: {
+    /** The run's policy reads or writes the local layer. */
+    local: boolean
+    localWrite: boolean
+    /** A remote layer exists and the policy reads or writes it. */
+    remote: boolean
+    /** The run's uploads, filled as each lands (a live ref). */
+    uploads: { count: number; failed: number }
+    /** Tasks whose outputs are still in the remote store. */
+    notDownloaded: () => number
+  }
   /** Total projects discovery found — the bar's denominator. */
   workspaceProjectCount?: number
 }
@@ -164,25 +158,25 @@ export function formatSummarySection(
   const row = (label: string, value: string): string => `  ${dim(label.padEnd(8))}  ${value}`
   const join = (parts: string[]): string => parts.join(` ${dim('\u00b7')} `)
 
-  // Tasks meter + numbers, fixed order: failed · success · skipped,
-  // then a dim total so the legend reads against the whole graph.
+  // Tasks meter + numbers, fixed order: failed · success · skipped ·
+  // aborted · not run, then a dim total, last on its line. Every task in
+  // the run counts, each state its own segment (M, 2026-10-14).
+  const runTotal = stats.total + aborted + notRun
   const taskParts: string[] = []
   if (stats.failed > 0)
     taskParts.push(paint(ERROR, `${stats.failed} failed`, colors, { bold: true }))
   if (stats.successful > 0) taskParts.push(paint(SUCCESS, `${stats.successful} success`, colors))
   if (stats.skipped > 0) taskParts.push(paint(WARN, `${stats.skipped} skipped`, colors))
-  if (stats.total > 0) taskParts.push(dim(`${stats.total} total`))
-  // Rows in the task list, but outside `total`: history and telemetry count
-  // the same tasks the total does, and an aborted task did no work.
-  const uncounted: string[] = []
-  if (aborted > 0) uncounted.push(paint(ABORTED, `${aborted} aborted`, colors))
-  if (notRun > 0) uncounted.push(dim(`${notRun} not run`))
-  if (uncounted.length > 0) taskParts.push(`${dim('not counted:')} ${uncounted.join(dim(', '))}`)
+  if (aborted > 0) taskParts.push(paint(ABORTED, `${aborted} aborted`, colors))
+  if (notRun > 0) taskParts.push(paint(NOT_RUN, `${notRun} not run`, colors))
+  if (runTotal > 0) taskParts.push(dim(`${runTotal} total`))
   const taskBar = segmentBar(
     [
       { n: stats.failed, color: ERROR },
       { n: stats.successful, color: SUCCESS },
       { n: stats.skipped, color: WARN },
+      { n: aborted, color: ABORTED },
+      { n: notRun, color: NOT_RUN },
       remainder,
     ],
     colors,
@@ -211,7 +205,7 @@ export function formatSummarySection(
         paint('', '▱'.repeat(BAR_WIDTH - cells), colors, { dim: true })
       lines.push(
         row('projects', bar),
-        legend([paint(WARN, `${context.packageCount} in run`, colors), dim(`${wsTotal} total`)]),
+        legend([paint(WARN, `${context.packageCount} affected`, colors), dim(`${wsTotal} total`)]),
       )
     }
   }
@@ -233,8 +227,8 @@ export function formatSummarySection(
     if (taskParts.length > 0) lines.push(legend(taskParts))
   }
 
-  // Cache meter + numbers, fixed order: miss · up-to-date · local ·
-  // remote.
+  // Cache meter + numbers: per layer when the run context names its
+  // layers, else miss · no-cache · up-to-date · local · remote.
   if (miss + noCache + hits + left + stats.skipped > 0) {
     const cacheBar = segmentBar(
       [
@@ -249,34 +243,80 @@ export function formatSummarySection(
       colors,
     )
     const cacheParts: string[] = []
-    if (miss > 0) cacheParts.push(paint(ERROR, `${miss} miss`, colors))
-    if (noCache > 0) cacheParts.push(paint('', `${noCache} no-cache`, colors, { dim: true }))
-    if (stats.upToDate > 0) cacheParts.push(paint(SUCCESS, `${stats.upToDate} up-to-date`, colors))
-    if (stats.restoredLocal > 0)
-      cacheParts.push(paint(LOCAL, `${stats.restoredLocal} local`, colors))
-    if (stats.restoredRemote > 0)
-      cacheParts.push(paint(REMOTE, `${stats.restoredRemote} remote`, colors))
-    // Skipped tasks have no cache provenance, but omitting them made
-    // the cache legend sum below the tasks legend (owner-reported
-    // confusion) — on the bar and in the legend, yellow like the
-    // tasks meter.
-    if (stats.skipped > 0) cacheParts.push(paint(WARN, `${stats.skipped} skipped`, colors))
+    const layers = context?.cache
+    if (layers !== undefined) {
+      // Per layer (M, 2026-10-15): `●` fresh (outputs already on disk, from
+      // either layer) and `○` no cache, both local; `↓` restored from a
+      // layer, `↑` saved to it.
+      const n = (count: number, glyph: string): string[] => (count > 0 ? [`${count}${glyph}`] : [])
+      const local = [
+        ...(layers.local ? n(stats.upToDate, '\u25cf') : []),
+        ...n(noCache, '\u25cb'),
+        ...(layers.local ? n(stats.restoredLocal, '\u2193') : []),
+        ...(layers.localWrite ? n(stats.saved ?? 0, '\u2191') : []),
+      ]
+      if (local.length > 0) cacheParts.push(paint(LOCAL, `local ${local.join(' ')}`, colors))
+      const remote = [...n(stats.restoredRemote, '\u2193'), ...n(layers.uploads.count, '\u2191')]
+      if (layers.remote && remote.length > 0)
+        cacheParts.push(paint(REMOTE, `remote ${remote.join(' ')}`, colors))
+      if (layers.uploads.failed > 0)
+        cacheParts.push(paint(ERROR, `${layers.uploads.failed} \u2191 failed`, colors))
+      if ((stats.notSaved ?? 0) > 0)
+        cacheParts.push(paint(WARN, `${stats.notSaved} not saved`, colors))
+      const notDownloaded = layers.notDownloaded()
+      if (notDownloaded > 0) cacheParts.push(paint(WARN, `${notDownloaded} not downloaded`, colors))
+    } else {
+      if (miss > 0) cacheParts.push(paint(ERROR, `${miss} miss`, colors))
+      if (noCache > 0) cacheParts.push(paint('', `${noCache} no-cache`, colors, { dim: true }))
+      if (stats.upToDate > 0)
+        cacheParts.push(paint(SUCCESS, `${stats.upToDate} up-to-date`, colors))
+      if (stats.restoredLocal > 0)
+        cacheParts.push(paint(LOCAL, `${stats.restoredLocal} local`, colors))
+      if (stats.restoredRemote > 0)
+        cacheParts.push(paint(REMOTE, `${stats.restoredRemote} remote`, colors))
+    }
+    // Skipped tasks ride the bar, yellow like the tasks meter, so the two
+    // bars fill alike; their count is the tasks legend's alone (the footer
+    // never says a fact twice, M, 2026-10-14).
     lines.push(row('cache', cacheBar))
     if (cacheParts.length > 0) lines.push(legend(cacheParts))
   }
 
   // Cache-miss duration spread (owner: hits' restore times polluted
   // it — only tasks that actually executed count). Dim: context.
-  let spread = ''
-  if (stats.spread !== null && stats.spread.count > 0) {
+  // A value already on the row is not said again: one executed task read
+  // as its own max, avg and min (M, 2026-10-14). Tasks that all took the
+  // same time have no spread to show.
+  const total = formatElapsed(totalMs)
+  const said = new Set([total])
+  const spreadParts: string[] = []
+  if (
+    stats.spread !== null &&
+    formatElapsed(stats.spread.maxMs) !== formatElapsed(stats.spread.minMs)
+  ) {
     const { maxMs, minMs, sumMs, count } = stats.spread
-    spread = ` ${dim(`\u00b7 max ${formatElapsed(maxMs)} \u00b7 avg ${formatElapsed(sumMs / count)} \u00b7 min ${formatElapsed(minMs)}`)}`
+    for (const [label, ms] of [
+      ['max', maxMs],
+      ['avg', sumMs / count],
+      ['min', minMs],
+    ] as const) {
+      const v = formatElapsed(ms)
+      if (said.has(v)) continue
+      said.add(v)
+      spreadParts.push(`${label} ${v}`)
+    }
   }
+  const timeParts = [total]
+  // What the cache paid back, beside what the run cost: the stored exec
+  // time of every hit, never the restore this run spent on it.
+  if ((stats.savedMs ?? 0) >= 1)
+    timeParts.push(paint(SUCCESS, `${formatElapsed(stats.savedMs!)} saved`, colors))
   // The live run's forecast leads the spread: the one number on the row
   // that is about the future.
-  if (stats.etaMs !== undefined) {
-    spread = ` ${dim('\u00b7')} ${paint(ACCENT, `${formatEta(stats.etaMs)} left`, colors)}${spread}`
-  }
+  if (stats.etaMs !== undefined)
+    timeParts.push(paint(ACCENT, `${formatEta(stats.etaMs)} left`, colors))
+  for (const p of spreadParts) timeParts.push(dim(p))
+  const timeRow = row('time', join(timeParts))
   // Run-shape footer (final summary only): worker pool + cache mode,
   // grouped with time under a blank line below the meters.
   if (context !== undefined) {
@@ -294,12 +334,9 @@ export function formatSummarySection(
         `admit held ${stats.held.count} task${stats.held.count === 1 ? '' : 's'}, ${formatElapsed(stats.held.sumMs)} in all`,
       )
     }
-    lines.push('', row('info', join(info)), row('time', `${formatElapsed(totalMs)}${spread}`))
-    // The run in one line, last, where the eye lands: what a Turbo user
-    // reads first in its own summary (tasks, cached, time), in vx's words.
-    if (stats.total > 0) lines.push(row('result', resultLine(stats, hits, totalMs, colors)))
+    lines.push('', row('info', join(info)), timeRow)
   } else {
-    lines.push('', row('time', `${formatElapsed(totalMs)}${spread}`))
+    lines.push('', timeRow)
   }
   return lines
 }
@@ -315,41 +352,6 @@ function formatEta(ms: number): string {
   return `~${Math.floor(s / 60)}m ${String(s % 60).padStart(2, '0')}s`
 }
 
-/**
- * `42 tasks · 38 cached (90%) · 3.2s`, `2 tasks · all cached · 23ms`,
- * with the failures first when there are any. Cached is every hit (up to
- * date, restored locally or remotely) over every task that consulted a
- * cache: a skipped or not-yet-run task never did.
- */
-function resultLine(
-  stats: SummaryStats,
-  hits: number,
-  totalMs: number,
-  colors: ColorSupport,
-): string {
-  const parts = [`${stats.total} task${stats.total === 1 ? '' : 's'}`]
-  if (stats.failed > 0) parts.push(paint(ERROR, `${stats.failed} failed`, colors, { bold: true }))
-  // A task with no `cache` block could never hit: it is counted apart, not
-  // as a miss, or `vx run dev` would read "0 cached (0%)". A skipped task
-  // never asked either, and counted as a miss it put "0 cached (0%)" on a
-  // run in which no task has a cache.
-  const noCache = stats.noCache ?? 0
-  const cacheable = stats.total - noCache - stats.skipped - (stats.left ?? 0)
-  if (cacheable > 0)
-    parts.push(
-      hits === cacheable
-        ? paint(SUCCESS, 'all cached', colors, { bold: true })
-        : `${hits} cached (${Math.floor((hits / cacheable) * 100)}%)`,
-    )
-  if (noCache > 0) parts.push(paint('', `${noCache} no-cache`, colors, { dim: true }))
-  // What the cache paid back, beside what the run cost: the stored exec
-  // time of every hit, never the restore this run spent on it.
-  if ((stats.savedMs ?? 0) >= 1)
-    parts.push(paint(SUCCESS, `${formatElapsed(stats.savedMs!)} saved`, colors))
-  parts.push(formatElapsed(totalMs))
-  return parts.join(` ${paint('', '\u00b7', colors, { dim: true })} `)
-}
-
 /**
  * The `--verbosity 1` per-task table (`RunOptions.summaryTable`). Groups are
  * left out as the footer and `--report` leave them: a group ran no command.
@@ -380,6 +382,11 @@ export function formatOutcomeTable(outcomes: readonly TaskOutcome[]): string[] {
 
 // Local byte formatter — the orchestrator can't import cli/format.ts
 // (module boundary), and the footer only needs one compact form.
+/** Ran here with a `cache` block, succeeded, and its result was not saved. */
+export function ranUnsaved(o: TaskOutcome): boolean {
+  return o.status === 'success' && !ranNoCache(o) && o.saved !== true && o.where === undefined
+}
+
 export function formatRunSummary(
   outcomes: readonly TaskOutcome[],
   totalMs: number,
@@ -418,6 +425,8 @@ export function formatRunSummary(
       upToDate: t.upToDate,
       restoredLocal: t.restoredLocal,
       restoredRemote: t.restoredRemote,
+      saved: outcomes.filter((o) => o.saved === true && !isGroupTask(o.node)).length,
+      notSaved: outcomes.filter((o) => !isGroupTask(o.node) && ranUnsaved(o)).length,
       miss: t.total - t.skipped - (t.cachedLocal + t.cachedRemote) - noCache,
       noCache,
       savedMs,

package/src/orchestrator/task-hash.ts

@@ -21,12 +21,8 @@ import { isUserError, relPosix, secretMask, span, UserError, xxh3hex } from '../
 import { expandGroupUpstream, filterUpstreamHashes } from './upstream.js'
 
 /**
- * Per-run memoization caches for the two derived hashes that don't
- * change across tasks within one run:
- *   - `packageJson`: keyed by absolute projectDir. Every task in a
- *     project re-reads the same `package.json`; without this, a
- *     monorepo with N projects × M tasks per project does N×M reads
- *     of the same bytes.
+ * Per-run memoization caches for what doesn't change across tasks within
+ * one run:
  *   - `projectFiles`: keyed by the project and its input DECLARATION.
  *     Tasks of one project that declare the same inputs and outputs
  *     resolve the same file list; see `ProjectFilesCache`.
@@ -35,11 +31,10 @@ import { expandGroupUpstream, filterUpstreamHashes } from './upstream.js'
  *     JSON.stringify + xxh3 of it is deterministic. WeakMap so
  *     entries free when the orchestrator is done.
  *
- * Both fields are optional — the helpers fall back to computing
- * fresh when the cache is missing.
+ * The whole memo is optional — the helpers fall back to computing
+ * fresh when it is missing.
  */
 export interface HashCache {
-  packageJson: Map<string, Promise<string>>
   taskConfig: WeakMap<TaskConfig, string>
   runtime: Map<string, Promise<string>>
   workspaceRuntime: Map<string, Promise<string>>
@@ -49,7 +44,6 @@ export interface HashCache {
 
 export function createHashCache(): HashCache {
   return {
-    packageJson: new Map(),
     taskConfig: new WeakMap(),
     runtime: new Map(),
     workspaceRuntime: new Map(),
@@ -76,7 +70,6 @@ export interface ComputeHashArgs {
   node: TaskNode
   upstream: TaskOutcome[]
   workspaceRoot: string
-  workspaceFingerprint: string
   cache: CacheLayer
   forwardArgs?: readonly string[] | undefined
   nestedProjectDirs: string[]
@@ -100,8 +93,7 @@ export interface ComputeHashArgs {
 
 /**
  * Resolve every input the cache key depends on (file content, env
- * values, upstream hashes, config bytes, project package.json bytes,
- * forwardArgs) and ask the cache layer to combine them. Used by both
+ * values, upstream hashes, config bytes, forwardArgs) and ask the cache layer to combine them. Used by both
  * `executeTask` for the real run and `plan()` for `--dry-run` /
  * `--graph` previews.
  *
@@ -161,22 +153,12 @@ export async function describeTaskInputs(args: ComputeHashArgs): Promise<{
       ? []
       : [{ path: relPosix(input.workspaceRoot, f), digest: digests[i]! }],
   )
-  // The package.json digest is a per-run memo that may predate this
-  // describe, so it is dated from the enumeration, the earliest a run
-  // learns anything.
   const indexedAt = args.gitFilesCache?.enumeratedAtMs ?? 0
   const facts: InputFact[] = sorted.map((f, i) => ({
     path: f,
     digest: digests[i]!,
     since: input.fileHashes?.has(f) === true ? indexedAt : hashedAt,
   }))
-  if (input.projectPackageJsonHash !== '') {
-    facts.push({
-      path: path.join(args.node.projectDir, 'package.json'),
-      digest: input.projectPackageJsonHash,
-      since: indexedAt,
-    })
-  }
   // Groups expanded: this list describes the INPUT ROOT, not the key, and a
   // group produces nothing of its own (see `CacheKeyInput.upstreamGraft`).
   // Sorted by hash so the list — and any action digest derived from it — is
@@ -220,9 +202,7 @@ export async function describeTaskInputs(args: ComputeHashArgs): Promise<{
       get upstream() {
         return (upstream ??= listUpstream())
       },
-      packageJsonDigest: input.projectPackageJsonHash,
       configDigest: input.taskConfigHash,
-      workspaceFingerprint: input.workspaceFingerprint,
     },
   }
 }
@@ -238,15 +218,17 @@ export async function describeTaskInputs(args: ComputeHashArgs): Promise<{
  * input changed and changed BACK while the command ran matched its digest
  * again, and the entry saved the other content's output under the key (item
  * 1015). A write before it — an upstream's — is judged by content, as before.
- * `writesByBytes` (`inputStability.strategy: 'mutable'`) judges a write
- * during the command by content too: the task says the same bytes are its
- * own identical rewrite (tsdown's package.json), not an edit undone.
+ * `byBytes` (`inputStability.strategy: 'mutable'`) judges a write during
+ * the command by content too, when it answers true for that file and its
+ * ctime: the task says the same bytes are its own identical rewrite
+ * (tsdown's package.json), not an edit undone, unless another command that
+ * may write the file ran until then (command-windows.ts).
  */
 export async function movedInput(
   facts: readonly InputFact[],
   cache: CacheLayer,
   commandFrom?: number,
-  writesByBytes = false,
+  byBytes?: (file: string, ctimeMs: number) => boolean,
 ): Promise<string | undefined> {
   const suspects: InputFact[] = []
   for (const f of facts) {
@@ -264,7 +246,7 @@ export async function movedInput(
     // an even one, FAT's tick), one during the command included
     // (`racyWindowMs`).
     if (commandFrom !== undefined && ctimeMs >= commandFrom - racyWindowMs(ctimeMs, 0)) {
-      if (!writesByBytes) return f.path
+      if (byBytes?.(f.path, ctimeMs) !== true) return f.path
       suspects.push(f)
       continue
     }
@@ -344,12 +326,6 @@ async function resolveKeyInput(
     }
   }
   const taskConfigHash = hashTaskConfig(cfg, args.hashCache)
-  const projectPackageJsonHash = await hashProjectPackageJson(
-    args.node.projectDir,
-    args.cache,
-    args.hashCache,
-    fileHashes,
-  )
 
   // Args after `--` reach a requested command; the default build (a keyed
   // group) runs none, and folded, they moved every key that folds its own.
@@ -359,7 +335,6 @@ async function resolveKeyInput(
   const input: CacheKeyInput = {
     taskId: args.node.id,
     taskConfigHash,
-    projectPackageJsonHash,
     envValues: resolved.envValues,
     runtimeValues: resolved.runtimeValues,
     workspaceRuntimeValues: resolved.workspaceRuntimeValues,
@@ -368,7 +343,6 @@ async function resolveKeyInput(
     upstreamHashes,
     upstreamIds,
     upstreamGraft,
-    workspaceFingerprint: args.workspaceFingerprint,
     forwardArgs: effectiveForwardArgs,
     ...(fileHashes !== undefined ? { fileHashes } : {}),
     ...(args.node.keyParts !== undefined ? { pluginParts: args.node.keyParts } : {}),
@@ -462,48 +436,3 @@ export function computeGroupHash(upstream: TaskOutcome[]): string {
     .join('|')
   return xxh3hex(`group|${ids}`)
 }
-
-/**
- * Hash the project's `package.json` bytes. Folded into every task's
- * cache key in that project so dep changes (devDependencies, scripts,
- * version bumps) invalidate the project's tasks even when
- * `cache.inputs.files` is narrow and doesn't cover the file.
- *
- * Matches Turbo and Nx's "implicit dependencies" behavior. Returns
- * '' for the edge case of a project without a package.json (impossible
- * in practice — workspace discovery requires one).
- *
- * Two optimizations: routed through `Cache.hashFile` so the mtime+size
- * fast path applies (an unchanged pkg.json takes a stat + SQLite SELECT
- * instead of a full file read). And memoized within-run per projectDir
- * so a monorepo with 100 projects × 3 tasks each does 100 lookups, not
- * 300.
- */
-async function hashProjectPackageJson(
-  projectDir: string,
-  cache: CacheLayer,
-  hashCache?: HashCache,
-  fileHashes?: ReadonlyMap<string, string>,
-): Promise<string> {
-  const cached = hashCache?.packageJson.get(projectDir)
-  if (cached !== undefined) return cached
-  const promise = doHashProjectPackageJson(projectDir, cache, fileHashes)
-  hashCache?.packageJson.set(projectDir, promise)
-  return promise
-}
-
-async function doHashProjectPackageJson(
-  projectDir: string,
-  cache: CacheLayer,
-  fileHashes?: ReadonlyMap<string, string>,
-): Promise<string> {
-  const filePath = path.join(projectDir, 'package.json')
-  // Clean tracked package.json: its index OID is already in hand —
-  // no exists probe, no stat, no SQLite.
-  const oid = fileHashes?.get(filePath)
-  if (oid !== undefined) return oid
-  if (!(await Bun.file(filePath).exists())) return ''
-  // Route through the cache layer's mtime+size fast path so the
-  // typical re-run sees a stat + SQLite lookup instead of a file read.
-  return cache.hashFile(filePath)
-}

package/src/orchestrator/telemetry.ts

@@ -117,7 +117,7 @@ export interface RunContextRecord {
   /** The invocation command line (process.argv-derived), what follows `--` counted, not quoted. */
   command: string
   requestedTasks: readonly string[]
-  /** Compact cache-policy flags, e.g. `'lR,lW,rR,rW'`. */
+  /** The `--cache-policy` spec, e.g. `'local:rw,remote:r'`. */
   cachePolicy: string
   concurrency: number
   flow: 'focused' | 'broad' | null
@@ -191,11 +191,11 @@ export interface TaskTelemetry {
   /** Executor-reported placement (a worker id) — absent for local runs.
    *  Additive-optional, no schema bump (the `attempts` precedent). */
   where?: string
-  /** `'deferred'` when the outputs stayed remote (`--download=none`).
+  /** `'deferred'` when the outputs stayed remote (`--cache-download=none`).
    *  Additive-optional, same no-bump precedent as `where`. */
   outputs?: 'deferred'
   /** Total attempts when the task RETRIED (>1) — set only when `exec.retries`
-   *  / `--retry` produced more than one attempt. A retried-then-passed task is
+   *  / `--retries` produced more than one attempt. A retried-then-passed task is
    *  flaky by definition; this is the telemetry-side flaky signal. */
   attempts?: number
   /**
@@ -340,7 +340,7 @@ export interface RunSummaryRecord {
   exitOk: boolean
   tasks: readonly TaskTelemetry[]
   /**
-   * The run's stages as `VX_TIMING` marks them (startup, load configs,
+   * The run's stages as `VX_DEBUG_TIMING` marks them (startup, load configs,
    * classify + probe, run graph, …), each a wall window in epoch ms. The
    * stages ahead of the run lock end before `startedAt`. Additive.
    */