@vzn/vx 0.0.650 → 0.0.652

package/src/orchestrator/stable-keys.ts

@@ -89,14 +89,14 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
   // reached through a no-output intermediate still poisons the key, so each
   // dep's accumulated producers fold forward.
   //   - outputProjects: the project names of every upstream task declaring
-  //     cache.outputs.files (project-relative outputs land in the producer's
-  //     own dir), and of every upstream with no cache block that may write
+  //     outputs.files (project-relative outputs land in the producer's
+  //     own dir), and of every upstream with no `cache: true` that may write
   //     in its own project (`undeclaredWriteReach`, item 743). A bitset over
   //     project indexes: a union per dep was a string Set copied tasks ×
   //     deps × projects times, 101 ms of a 513 ms warm run at 476 packages
   //     (item 744).
-  //   - wsOutputUpstream: any upstream declares cache.outputs.workspaceFiles
-  //     (root-anchored, boundary-ignoring outputs), or has no cache block
+  //   - wsOutputUpstream: any upstream declares outputs.workspaceFiles
+  //     (root-anchored, boundary-ignoring outputs), or has no `cache: true`
   //     and a sandbox write grant elsewhere in the workspace, or may rewrite
   //     a root file a plugin claims (a root `pnpm install`): every key folds
   //     what the claimant took from it, once per run.
@@ -125,7 +125,7 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
   // of what any one reader's upstream producers declare.
   const outputsOf = new Map<string, string[]>()
   for (const n of args.nodes.values()) {
-    const files = n.config.cache?.outputs.files ?? []
+    const files = n.config.outputs?.files ?? []
     if (files.length === 0) continue
     const list = outputsOf.get(n.projectName)
     if (list === undefined) outputsOf.set(n.projectName, [...files])
@@ -185,10 +185,10 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
         const wideOfDep = wideById.get(dep)
         if (wideOfDep !== undefined) wideUnion.addAll(wideOfDep)
         if (wsOutputUpstreamById.get(dep) === true) wsOutputUpstream = true
-        const depOut = depNode.config.cache?.outputs
+        const depOut = depNode.config.outputs
         if ((depOut?.files?.length ?? 0) > 0) outputs.add(depNode.projectName)
         if ((depOut?.workspaceFiles?.length ?? 0) > 0) wsOutputUpstream = true
-        // An uncached producer declares no outputs, yet a same-project reader
+        // An uncached producer is held to no outputs, yet a same-project reader
         // after it (`tasks: []` decouples the key, not the order) read the
         // bytes it wrote: its key taken up front was the pre-producer one, and
         // the fourth run of seeds A,B,B,A replayed B over A (turborepo#13788).
@@ -198,7 +198,7 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
           wideUnion.add(depNode.projectName)
         } else if (reach === 'workspace') wsOutputUpstream = true
         if (
-          depNode.config.cache === undefined &&
+          depNode.config.cache !== true &&
           mayWriteFingerprint(depNode, args.workspaceRoot, args.claimedFiles)
         )
           wsOutputUpstream = true
@@ -219,7 +219,7 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
     for (const dep of anyUnfolded ? node.deps : []) {
       const depNode = args.nodes.get(dep)
       if (!depNode) continue
-      const cached = depNode.config.cache !== undefined
+      const cached = depNode.config.cache === true
       // The cached twin: a formatter rewriting its own input ahead of a
       // reader that folds no key of it replayed seed B's build under seed A
       // on the fourth run, the same way (item 750).
@@ -323,7 +323,7 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
       )
     if (unstable) unstableById.add(id)
 
-    const cacheEnabled = node.config.cache !== undefined
+    const cacheEnabled = node.config.cache === true
     if (cacheEnabled && !unstable) stableKeys.push({ hash, node })
     // An uncached key stays preliminary behind any upstream that may write
     // into this project, or anywhere: none of its writes is declared.
@@ -438,7 +438,7 @@ export function gatedOutputs(
   // 1,000 projects' tasks spent 5-8 ms here re-splitting the same globs.
   const outputsOf = new Map<string, ProjectOutputs>()
   for (const n of nodes.values()) {
-    const files = n.config.cache?.outputs.files
+    const files = n.config.outputs?.files
     if (files === undefined || files.length === 0) continue
     let po = outputsOf.get(n.projectName)
     if (po === undefined) outputsOf.set(n.projectName, (po = new ProjectOutputs()))
@@ -554,8 +554,8 @@ export function probesAfterWrites(
   for (const n of nodes.values()) {
     if (
       commandWriteReach(n, workspaceRoot) !== 'none' ||
-      (n.config.cache?.outputs.files.length ?? 0) > 0 ||
-      (n.config.cache?.outputs.workspaceFiles?.length ?? 0) > 0
+      (n.config.outputs?.files.length ?? 0) > 0 ||
+      (n.config.outputs?.workspaceFiles?.length ?? 0) > 0
     )
       writers.add(n.id)
   }
@@ -581,7 +581,7 @@ export function probesAfterWrites(
     }
     if (writer) writerBelow.add(id)
     if (unfolded) unfoldedBelow.add(id)
-    if (unfolded && node.config.cache !== undefined && probes(node)) late.add(id)
+    if (unfolded && node.config.cache === true && probes(node)) late.add(id)
   }
   return late
 }
@@ -628,8 +628,8 @@ function synthUpstream(
  * Conservative stability check: does any TRANSITIVE-upstream task whose
  * outputs could land where this task reads its inputs make this task's
  * key preliminary? The producers are pre-folded by `deriveStableKeys`
- * (`upstreamOutputProjects` = projects declaring `cache.outputs.files`
- * upstream; `hasWsOutputUpstream` = any `cache.outputs.workspaceFiles`
+ * (`upstreamOutputProjects` = projects declaring `outputs.files`
+ * upstream; `hasWsOutputUpstream` = any `outputs.workspaceFiles`
  * upstream), so a producer reached through a no-output intermediate is
  * caught too.
  *
@@ -663,7 +663,6 @@ export function dependsOnSiblingOutputs(
     readableOf?: ReadonlyMap<string, readonly string[]>
   },
 ): boolean {
-  const cache = node.config.cache
   const declared = node.config.inputs
   // A task with no inputs has no key to take up front.
   if (declared === undefined) return false
@@ -697,7 +696,7 @@ export function dependsOnSiblingOutputs(
     // that producer, its restore raced the producer's clean and extract
     // (M-5; invariant 2 of docs/design/overlapping-outputs-2026-09.md).
     // `outputsOf` holds this task's own globs too; set them aside once.
-    const own = cache?.outputs.files ?? []
+    const own = node.config.outputs?.files ?? []
     if (own.length > 0) {
       const others = [...outputs]
       for (const g of own) {

package/src/orchestrator/task-artifacts.ts

@@ -22,7 +22,7 @@ export interface ArtifactTask {
   /** Absolute. */
   readonly projectDir: string
   readonly command: string
-  /** Its `cache.outputs`: project-relative `files`, root-relative `workspaceFiles`. */
+  /** Its `outputs`: project-relative `files`, root-relative `workspaceFiles`. */
   readonly outputs: {
     readonly files: readonly string[]
     readonly workspaceFiles: readonly string[]

package/src/orchestrator/task-hash.ts

@@ -292,7 +292,7 @@ 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.
- * `byBytes` (`inputStability.strategy: 'mutable'`) judges a write during
+ * `byBytes` (`inputs.stability.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
@@ -353,14 +353,14 @@ export function taskFilesToken(
 /** What `resolveInputs` is asked for a task's key. */
 function inputsArgs(args: ComputeHashArgs): ResolveInputsArgs {
   const cfg = args.node.config
-  const cacheCfg = cfg.cache
+  const cfgOut = cfg.outputs
   return {
     projectDir: args.node.projectDir,
     workspaceRoot: args.workspaceRoot,
     envSource: process.env,
     inputs: cfg.inputs,
-    ownOutputs: cacheCfg?.outputs.files ?? [],
-    ownWorkspaceOutputs: cacheCfg?.outputs.workspaceFiles ?? [],
+    ownOutputs: cfgOut?.files ?? [],
+    ownWorkspaceOutputs: cfgOut?.workspaceFiles ?? [],
     nestedProjectDirs: args.nestedProjectDirs,
     ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
     ...(args.probesAfterWrites?.has(args.node.id) === true ? { runtimeScope: args.node.id } : {}),
@@ -519,9 +519,23 @@ function hashableConfig(cfg: TaskConfig): unknown {
   // Keys sorted: moving `cache` above `exec`, or a `define` in another
   // order, missed every key of the task, and a `project` or `graph` plugin
   // writes a config the lock never sorted (2026-10-25).
-  if (cfg.exec?.remote === undefined) return keysSorted(cfg)
-  const { remote: _remote, ...execRest } = cfg.exec
-  return keysSorted({ ...cfg, exec: execRest })
+  const env = cfg.inputs?.env
+  const pass = cfg.exec?.env?.passThrough
+  if (cfg.exec?.remote === undefined && sortedNames(env) && sortedNames(pass))
+    return keysSorted(cfg)
+  const { remote: _remote, ...execRest } = cfg.exec ?? ({} as NonNullable<TaskConfig['exec']>)
+  // Env names are sets: each value is read by its name, so their order
+  // keys nothing (conformance env/declared-order-irrelevant).
+  if (!sortedNames(pass)) execRest.env = { ...execRest.env, passThrough: [...pass!].sort() }
+  const out: TaskConfig = cfg.exec === undefined ? { ...cfg } : { ...cfg, exec: execRest }
+  if (!sortedNames(env)) out.inputs = { ...cfg.inputs!, env: [...env!].sort() }
+  return keysSorted(out)
+}
+
+function sortedNames(names: readonly string[] | undefined): boolean {
+  if (names === undefined) return true
+  for (let i = 1; i < names.length; i++) if (names[i - 1]! > names[i]!) return false
+  return true
 }
 
 /**

package/src/orchestrator/telemetry.ts

@@ -16,7 +16,7 @@
 // what or how tasks run. Contrast `cache`/`executor`, which return objects
 // core calls INTO; those are the behavior capabilities, kept separate.
 
-import { sampleTrees, type MachineReport } from '../exec/index.js'
+import { sampleTrees, type MachineReport, type WorkerAdvice } from '../exec/index.js'
 import {
   type CacheSource,
   deriveCacheSource,
@@ -301,6 +301,8 @@ export interface RunSummaryRecord {
    * (`TaskExecutor.idealMs`), beside `totalDurationMs`. Additive.
    */
   idealMs?: number
+  /** The workers that would have run it best (`TaskExecutor.advice`). Additive. */
+  advice?: readonly WorkerAdvice[]
 }
 
 /** One stage of a run, a wall window in epoch ms. */
@@ -334,6 +336,7 @@ export function assembleRunSummary(
     uploads?: { count: number; bytes: number; ms: number; failed: number }
     machines?: readonly MachineReport[]
     idealMs?: number | undefined
+    advice?: readonly WorkerAdvice[]
   },
 ): RunSummaryRecord {
   let failedCount = 0
@@ -376,6 +379,7 @@ export function assembleRunSummary(
       ? { machines: timing.machines }
       : {}),
     ...(timing.idealMs !== undefined ? { idealMs: timing.idealMs } : {}),
+    ...(timing.advice !== undefined && timing.advice.length > 0 ? { advice: timing.advice } : {}),
   }
 }
 

package/src/report/events.ts

@@ -14,12 +14,12 @@ import type { Logger } from './logger.js'
 import type { RunContext } from './summary.js'
 
 /**
- * A task no cache answered for: it declares no `cache`, or the run's policy
+ * A task no cache answered for: it has no `cache: true`, or the run's policy
  * read and wrote nothing. Its run is `no-cache`, never a miss, on every
  * surface — `--dry`'s plan, the frame, the footer, the run history.
  */
 export function ranNoCache(o: { node: TaskNode; cacheOff?: boolean }): boolean {
-  return o.node.config.cache === undefined || o.cacheOff === true
+  return o.node.config.cache !== true || o.cacheOff === true
 }
 
 /** Payload of the `run:start` event — mirrors the Logger.runStart hook. */
@@ -45,7 +45,7 @@ export interface RunStartInfo {
  */
 export type RunEvent =
   | { kind: 'run:start'; info: RunStartInfo }
-  | { kind: 'task:start'; node: TaskNode; waitedMs?: number }
+  | { kind: 'task:start'; node: TaskNode }
   | { kind: 'task:stdout'; node: TaskNode; chunk: string }
   | { kind: 'task:stderr'; node: TaskNode; chunk: string }
   | { kind: 'task:complete'; node: TaskNode; outcome: TaskOutcome }
@@ -139,12 +139,7 @@ export function busLogger(bus: EventBus): Logger {
     taskStderr: (node, chunk) => bus.emit({ kind: 'task:stderr', node, chunk }),
     taskComplete: (node, outcome) => bus.emit({ kind: 'task:complete', node, outcome }),
     runStart: (info) => bus.emit({ kind: 'run:start', info }),
-    taskStart: (node, info) =>
-      bus.emit(
-        info?.waitedMs === undefined
-          ? { kind: 'task:start', node }
-          : { kind: 'task:start', node, waitedMs: info.waitedMs },
-      ),
+    taskStart: (node) => bus.emit({ kind: 'task:start', node }),
     runEnd: () => {
       if (ended) return
       ended = true
@@ -179,10 +174,7 @@ export function terminalSubscriber(sink: Logger): RunEventSubscriber {
         sink.runStart?.(event.info)
         return
       case 'task:start':
-        sink.taskStart?.(
-          event.node,
-          event.waitedMs === undefined ? undefined : { waitedMs: event.waitedMs },
-        )
+        sink.taskStart?.(event.node)
         return
       case 'task:stdout':
         sink.taskStdout(event.node, event.chunk)
@@ -289,7 +281,7 @@ export interface OutcomeView {
    * and counting groups as executed tasks drifts from the terminal.
    */
   isGroup?: boolean
-  /** Executed with no `cache` block: never consulted the cache, not a miss. */
+  /** Executed without `cache: true`: never consulted the cache, not a miss. */
   noCache?: boolean
   /** Cache hits only: the exec time the entry was stored with — the work
    *  this hit skipped, as opposed to `durationMs`, the restore it cost. */

package/src/report/forecast.ts

@@ -12,8 +12,6 @@ export interface LiveForecast {
   critical?: string
   /** Tasks not started because a dependency has not finished: the tasks line's `blocked`. */
   waiting: number
-  /** Each running task's p50, where history knows it: the row's expected duration. */
-  expected?: ReadonlyMap<string, number>
   /**
    * Tasks not started because a dependency has not finished, in the order
    * the scheduler would start them, at most one per worker: what an idle
@@ -21,13 +19,12 @@ export interface LiveForecast {
    */
   blocked?: readonly BlockedTask[]
   /**
-   * Each running task's count of the tasks downstream of it (a group,
-   * which runs nothing, looked through): its row's `blocks` cell, why they
-   * are not running. A task downstream of two running tasks counts under both.
+   * Each running task's count of what is downstream of it, the
+   * scheduler's own count (`computeReverseDepCount`): its row's `blocks`
+   * cell, why they are not running. A node downstream of two running tasks
+   * counts under both.
    */
   blockedBy: ReadonlyMap<string, number>
-  /** Each task's usual time (its executed p50), for the results' `±usual`. */
-  usual?: ReadonlyMap<string, number>
 }
 
 /** A task an unfinished dependency holds back, and what holds it: the running task its longest chain waits on, else that dependency. */
@@ -54,8 +51,8 @@ export function createForecast(
   nodes: ReadonlyMap<string, TaskNode>,
   p50s: ReadonlyMap<string, number>,
   concurrency: number,
-  /** Each task's count of the tasks downstream of it (`blocksCounts`); computed here when absent. */
-  downstream: ReadonlyMap<string, number> = blocksCounts(nodes),
+  /** Every node's dependents count, the scheduler's baseline and the rows' `blocks`; computed here when absent. */
+  rank: ReadonlyMap<string, number> = computeReverseDepCount(nodes),
 ): Forecast {
   // Dependencies before dependents, once: each call is one pass over it.
   const order: TaskNode[] = []
@@ -87,9 +84,8 @@ export function createForecast(
     if (p !== undefined) cost.set(n.id, p)
   }
   const workers = Math.max(1, concurrency)
-  // The scheduler's own baseline ranking, most dependents first, ties in
-  // graph order: once per run, as the scheduler computes it.
-  const rank = computeReverseDepCount(nodes)
+  // The scheduler's own baseline ranking (`rank`), most dependents first,
+  // ties in graph order.
   const position = new Map(order.map((n, i) => [n.id, i]))
   const before = (a: string, b: string): boolean => {
     const d = (rank.get(a) ?? 0) - (rank.get(b) ?? 0)
@@ -97,12 +93,7 @@ export function createForecast(
   }
 
   return (finished, running, nowMs) => {
-    const expected = new Map<string, number>()
     let waiting = 0
-    for (const id of running.keys()) {
-      const p = cost.get(id)
-      if (p !== undefined) expected.set(id, p)
-    }
     const end = new Map<string, number>()
     // The running task each node's longest chain waits on.
     const head = new Map<string, string>()
@@ -153,30 +144,17 @@ export function createForecast(
       work += own
     }
     for (const id of running.keys()) {
-      const d = downstream.get(id)
+      const d = rank.get(id)
       if (d !== undefined && d > 0) blockedBy.set(id, d)
     }
-    if (!known) return { waiting, expected, blocked: held, blockedBy, usual: cost }
+    if (!known) return { waiting, blocked: held, blockedBy }
     const critical = chainEnd === undefined ? undefined : head.get(chainEnd)
     return {
       etaMs: Math.max(chain, work / workers),
       ...(critical !== undefined ? { critical } : {}),
       waiting,
-      expected,
       blocked: held,
       blockedBy,
-      usual: cost,
     }
   }
 }
-
-/**
- * Each task's `blocks`: how many tasks, a group's own looked through and
- * none counted, sit downstream of it in the run, each once (2026-10-29:
- * every task it holds back, not only the next ones).
- */
-export function blocksCounts(nodes: ReadonlyMap<string, TaskNode>): Map<string, number> {
-  const tasks = new Map<string, true>()
-  for (const n of nodes.values()) if (!isGroupTask(n)) tasks.set(n.id, true)
-  return computeReverseDepCount(nodes, tasks)
-}