@vzn/vx 0.0.652 → 0.0.653

package/src/graph/folds.ts

@@ -10,6 +10,7 @@ import {
   parseDependencySpec,
   type DependencySpec,
 } from '../util/index.js'
+import { standInsOf, type StandIns } from './stand-ins.js'
 import type { TaskNode } from './task-graph.js'
 
 /**
@@ -36,9 +37,13 @@ export function keyedDeps(node: TaskNode): readonly string[] {
  * A filter selects among the task's own dependencies, never through a
  * group: `dependsOn: ['build']` over a group `build` of `build.a` and
  * `build.b` offers the filter `build`, not its members. A pattern that
- * matches only a member (`build.*`) therefore selected nothing, and the key stopped moving
- * with that member's inputs: a stale hit under a green run. Such a spec
- * is refused, once, over the graph every key site reads. One that matches
+ * matches a member (`build.*`) the filter folds neither directly nor
+ * through a selected group therefore left it out, and the key stopped
+ * moving with that member's inputs: a stale hit under a green run. That
+ * held when the pattern also matched another dependency directly
+ * (`dependsOn: ['build', 'build.a']`), so such a spec is refused, once,
+ * over the graph every key site reads, unless it matches the group
+ * itself (a negation of the group is a decision). One that matches
  * nothing anywhere stays legal (a preset's pattern needn't match in every
  * project). An exact name is refused earlier, at load, unless `dependsOn`
  * names it (`assertFilterNamesDeclaredDeps`).
@@ -49,20 +54,37 @@ export function refuseFiltersThroughGroups(nodes: ReadonlyMap<string, TaskNode>)
     if (filter === undefined || filter.length === 0) continue
     const deps = keyedDeps(node).flatMap((id) => nodes.get(id) ?? [])
     const groups = deps.filter(isGroupTask)
+    const folded = new Set<TaskNode>()
+    if (groups.length > 0) {
+      const units = deps.map((n) => ({ node: n, unit: n.id }))
+      const picked = selectFoldedDeps(units, filter, node.projectName, node.id, standInsOf(node))
+      for (const { node: n } of picked) {
+        folded.add(n)
+        if (isGroupTask(n)) for (const m of groupMembers(n, nodes)) folded.add(m)
+      }
+    }
     for (const raw of filter) {
       const spec = parseSpec(raw, node.id)
       if (spec.negated) continue
       const matches = specMatcher(spec)
       const hit = (n: TaskNode): boolean => matches(n, n.projectName === node.projectName)
-      if (deps.some(hit)) continue
+      const direct = deps.some(hit)
       for (const group of groups) {
-        const member = groupMembers(group, nodes).find(hit)
+        if (hit(group)) continue
+        const member = groupMembers(group, nodes).find(
+          (m) => hit(m) && !folded.has(m) && !deps.includes(m),
+        )
         if (member === undefined) continue
+        const outcome = direct ? 'so the key leaves it out' : 'so it selects nothing'
         throw new UserError(
-          `${node.id}: inputs.tasks: '${raw}' matches ${member.id} only through the group ${group.id}, so it selects nothing; name '${group.taskName}' or depend on ${member.id} directly`,
+          `${node.id}: inputs.tasks: '${raw}' matches ${member.id} only through the group ${group.id}, ${outcome}; name '${group.taskName}' or depend on ${member.id} directly`,
         )
       }
-      if (namesNoDependency(spec, node.config.dependsOn ?? [])) {
+      if (direct) continue
+      if (
+        namesNoDependency(spec, node.config.dependsOn ?? []) ||
+        namesTransitiveDependency(spec, node, nodes, hit)
+      ) {
         const named = deps.map((d) => d.id).join(', ') || 'none'
         throw new UserError(
           `${node.id}: inputs.tasks: '${raw}' names none of its dependencies (${named}), so it selects nothing and the key would not move with them; fix the name, or use [] to decouple on purpose`,
@@ -100,6 +122,34 @@ function namesNoDependency(spec: DependencySpec, dependsOn: readonly string[]):
   })
 }
 
+/**
+ * An exact `pkg#task` filter that matched no dependency but names a task the
+ * key reaches only through one. `namesNoDependency` lets it through when a
+ * `^` entry names the task (the preset whose project lacks that dependency),
+ * but `a → b → c` with `dependsOn: ['^build']` and `['c#build']` selected
+ * none of a's direct dependencies, and an edit to c replayed a's hit.
+ */
+function namesTransitiveDependency(
+  spec: DependencySpec,
+  node: TaskNode,
+  nodes: ReadonlyMap<string, TaskNode>,
+  hit: (n: TaskNode) => boolean,
+): boolean {
+  if (spec.kind !== 'cross' || isTaskPattern(spec.project) || isTaskPattern(spec.task)) return false
+  const seen = new Set<string>([node.id])
+  const stack = [...keyedDeps(node)]
+  while (stack.length > 0) {
+    const id = stack.pop()!
+    if (seen.has(id)) continue
+    seen.add(id)
+    const n = nodes.get(id)
+    if (n === undefined) continue
+    if (hit(n)) return true
+    stack.push(...keyedDeps(n))
+  }
+  return false
+}
+
 function parseSpec(raw: string, selfTaskId: string): DependencySpec {
   try {
     return parseDependencySpec(raw, 'inputs.tasks')
@@ -162,16 +212,26 @@ export interface FoldCandidate {
  *   - `filter === undefined` → every candidate, as given.
  *   - `filter === []`        → none (fully decoupled).
  *
- * Otherwise deduped by `unit`, first candidate kept. The unit is the
- * fold's own identity, not the task's: two groups over the same members
- * share one hash, so excluding either excludes both, and a selection by
- * task id would keep the other while the key folded neither.
+ * Otherwise deduped by `unit`, first selected candidate kept. The unit is
+ * the fold's own identity, not the task's: two groups over the same members
+ * share one hash. A negation drops only the candidates it names, and the
+ * dedup runs after every entry, so a unit still selected through another
+ * candidate stays folded: deleting by unit let `['^*', '!c#build']` drop
+ * b#build's group with c#build's, and a change beneath both replayed the
+ * old hit.
+ *
+ * `standIns` is the task's `standInsOf`: an edge added past a
+ * default build on a package cycle is selected whenever an edge it went
+ * past is. That build folds nothing of its cycle, so `['build']` on
+ * `a ↔ b` selected a#build alone, dropped b#build, and an edit to b
+ * replayed the old hit.
  */
 export function selectFoldedDeps(
   deps: readonly FoldCandidate[],
   filter: readonly string[] | undefined,
   selfProjectName: string,
   selfTaskId: string,
+  standIns?: StandIns,
 ): FoldCandidate[] {
   if (filter === undefined) return [...deps]
 
@@ -180,18 +240,25 @@ export function selectFoldedDeps(
   // Per-spec predicate, compiled once (exact compares + patterns).
   const matchers = specs.map((spec) => specMatcher(spec))
 
-  const selected = new Map<string, FoldCandidate>()
+  const selected = new Set<FoldCandidate>()
   for (let i = 0; i < specs.length; i++) {
     const spec = specs[i]!
     const matches = matchers[i]!
     for (const d of deps) {
       const isSelf = d.node.projectName === selfProjectName
       if (!matches(d.node, isSelf)) continue
-      if (spec.negated) selected.delete(d.unit)
-      else if (!selected.has(d.unit)) selected.set(d.unit, d)
+      if (spec.negated) selected.delete(d)
+      else selected.add(d)
     }
   }
-  return [...selected.values()]
+  if (standIns !== undefined) {
+    const ids = new Set<string>()
+    for (const d of selected) ids.add(d.node.id)
+    for (const d of deps) if (standIns[d.node.id]?.some((p) => ids.has(p))) selected.add(d)
+  }
+  const byUnit = new Map<string, FoldCandidate>()
+  for (const d of selected) if (!byUnit.has(d.unit)) byUnit.set(d.unit, d)
+  return [...byUnit.values()]
 }
 
 /** Exact-name compare, or the shared `*`-glob when the name is a pattern. */
@@ -250,7 +317,13 @@ export function foldedDeps(node: TaskNode, nodeOf: (id: string) => TaskNode): Fo
     candidates.push({ node: dep, unit: foldUnit(dep) })
   }
   if (isGroupTask(node) && node.config.inputs === undefined) return candidates
-  return selectFoldedDeps(candidates, node.config.inputs?.tasks, node.projectName, node.id)
+  return selectFoldedDeps(
+    candidates,
+    node.config.inputs?.tasks,
+    node.projectName,
+    node.id,
+    standInsOf(node),
+  )
 }
 
 /**

package/src/graph/index.ts

@@ -18,6 +18,7 @@ export {
 } from './folds.js'
 export { DEFAULT_BUILD, isDefaultBuild } from './default-build.js'
 export { computeReverseDepCount } from './priorities.js'
+export { setStandIns, type StandIns, standInsOf } from './stand-ins.js'
 export { criticalPath } from './critical-path.js'
 export { taskDefinition, taskDefinitions } from './definition.js'
 export {
@@ -26,6 +27,13 @@ export {
   idleServers,
   type InputChanges,
   RestoreDemoted,
+  isKeyFailed,
+  KeyFailed,
+  markKeyFailed,
+  markOutputsFailed,
+  OutputsFailed,
+  outputsFailedOf,
+  RestoreFailed,
   runGraph,
   type TaskOutcome,
 } from './scheduler.js'

package/src/graph/priorities.ts

@@ -347,10 +347,14 @@ export function strategyPriorities(
   return out
 }
 
+/**
+ * A task's merged weight, read as asked: a merged copy held an entry per
+ * task of the run beside the two maps it was made of.
+ */
 export function mergePriorities(
   baseline: ReadonlyMap<string, number>,
   overrides: ReadonlyMap<string, number>,
-): ReadonlyMap<string, number> {
+): (id: string) => number {
   // The override caller scored "expected critical-path duration" in ms.
   // Baseline reverse-deps counts are bounded by N; scale the override so
   // it sorts above the baseline for any node it covers, and add the
@@ -361,10 +365,9 @@ export function mergePriorities(
   const SCALE = 1 << 20
   let lo = 0
   for (const w of overrides.values()) if (w < lo) lo = w
-  const out = new Map(baseline)
-  for (const [id, w] of overrides) {
+  return (id) => {
     const b = baseline.get(id) ?? 0
-    out.set(id, (w - lo + 1) * SCALE + b)
+    const w = overrides.get(id)
+    return w === undefined ? b : (w - lo + 1) * SCALE + b
   }
-  return out
 }

package/src/graph/scheduler.ts

@@ -33,6 +33,81 @@ export class RestoreDemoted extends Error {
   }
 }
 
+/**
+ * Thrown by `execute` when restoring a cache hit threw (a full disk, a
+ * path in the way, a link out of the project). The run reports `error`
+ * as any throw, and the failed outcome says `restoreFailed`: a failed
+ * task, counted as neither a miss nor a hit.
+ */
+export class RestoreFailed extends Error {
+  constructor(readonly error: unknown) {
+    super(thrownMessage(error))
+    this.name = 'RestoreFailed'
+  }
+}
+
+/**
+ * Thrown by `execute` when deriving the task's key threw (a runtime probe
+ * that exited non-zero, a refused `inputs.env` value). The command never
+ * ran: the failed outcome is marked (`isKeyFailed`), and the line says so.
+ */
+export class KeyFailed extends Error {
+  constructor(readonly error: unknown) {
+    super(thrownMessage(error))
+    this.name = 'KeyFailed'
+  }
+}
+
+// A mark, not a field: `TaskOutcome` and `RunPlan` are public types. A symbol
+// rides a spread copy and never reaches JSON.
+const KEY_FAILED = Symbol('keyFailed')
+
+/** Mark a failed outcome (or a plan holding one) as having no derivable key. */
+export function markKeyFailed<T extends object>(o: T): T {
+  ;(o as Record<symbol, unknown>)[KEY_FAILED] = true
+  return o
+}
+
+/** Whether `markKeyFailed` marked it: no key, so no command ran and no cache was asked. */
+export function isKeyFailed(o: object): boolean {
+  return (o as Record<symbol, unknown>)[KEY_FAILED] === true
+}
+
+/**
+ * Thrown by `execute` when vx's own work on a miss's outputs threw: the
+ * clean before an attempt, or the save after an exit 0 (a name that is
+ * not UTF-8). The outcome keeps `exitCode` and `durationMs` (what the
+ * command returned and took so far) and is marked (`outputsFailedOf`),
+ * so no label names an exit the command never returned.
+ */
+export class OutputsFailed extends Error {
+  constructor(
+    readonly error: unknown,
+    readonly step: OutputsStep,
+    readonly exitCode: number,
+    readonly durationMs: number,
+  ) {
+    super(thrownMessage(error))
+    this.name = 'OutputsFailed'
+  }
+}
+
+type OutputsStep = 'clean' | 'save'
+
+// A mark, as KEY_FAILED: `TaskOutcome` is a public type.
+const OUTPUTS_FAILED = Symbol('outputsFailed')
+
+/** Mark a failed outcome (or its view) with the output step that failed it. */
+export function markOutputsFailed<T extends object>(o: T, step: OutputsStep): T {
+  ;(o as Record<symbol, unknown>)[OUTPUTS_FAILED] = step
+  return o
+}
+
+/** The output step `markOutputsFailed` marked, if any. */
+export function outputsFailedOf(o: object): OutputsStep | undefined {
+  return (o as Record<symbol, OutputsStep | undefined>)[OUTPUTS_FAILED]
+}
+
 /** What moved in a missed task's key since the last entry saved for it. */
 export interface InputChanges {
   /** How many components changed, appeared or went. 0: the same key, its entry gone. */
@@ -128,6 +203,13 @@ export interface TaskOutcome {
    * so a dependant that folds `hash` saves nothing either (A-12).
    */
   unkeyed?: true
+  /**
+   * The input this task's own re-check found moved while it ran (absolute),
+   * or null when the key re-derived before the command already differed.
+   * The command read a state of it no `vx watch` judgement saw, so the
+   * loop counts its next settled state as a change.
+   */
+  driftedInput?: string | null
   /**
    * The task with no `inputs` this task's key folds (this task, or one
    * upstream): no run can derive that key again, so it neither read nor
@@ -148,6 +230,14 @@ export interface TaskOutcome {
    * read this one field (item 267).
    */
   blockedBy?: string
+  /**
+   * On an outcome that ran behind a failed dependency (`continueMode:
+   * 'always'`), one `--exclude-dependencies` dropped, or a server that died
+   * while it ran: the task at the root of it. Its result is not its key's, so no flaky verdict reads it and
+   * its run row names the root as a skip's `blockedBy` does. Set by `run()`
+   * before any observer (a plugin's `onTaskComplete`) hears the outcome.
+   */
+  taintedBy?: string
   /**
    * On a `skipped` outcome: its `exec.platforms` leave out this machine.
    * Its dependants are skipped with `blockedBy` naming it, and neither
@@ -206,6 +296,12 @@ export interface TaskOutcome {
   outputs?: 'deferred'
   /** The task ran here and its result went to the cache. The footer's `↑`. */
   saved?: true
+  /**
+   * On a `failed` outcome: a cache hit whose restore threw, so no command
+   * ran. It counts as failed only, in no cache column: not a miss, not
+   * its layer's hit.
+   */
+  restoreFailed?: true
   /**
    * v11 analytics: hrtime span relative to the parent run's t=0.
    * Lets downstream analytics reconstruct the actual parallel timeline
@@ -336,6 +432,8 @@ export interface ScheduleOptions {
    * dispatch, the slot and the promise around it were ~10 µs of each of a
    * warm run's 1,090 groups (X-192); a hit whose tree is current does no
    * more. A restore-tier task's `upstream` may hold undefined entries.
+   * The thunk's outcome is the scheduler's: its queue time is set on it,
+   * not on a copy (a copy per hit, 2026-11-07).
    */
   settleNow?: (node: TaskNode, upstream: TaskOutcome[]) => (() => TaskOutcome) | undefined
   /**
@@ -431,23 +529,23 @@ export interface ScheduleOptions {
 class ReadyHeap {
   private readonly ids: string[] = []
   private readonly seq: number[] = []
-  // Each slot's priority, read once at push: a map lookup per comparison
+  // Each slot's priority, read once at push: a lookup per comparison
   // was two per heap level on every push and pop.
   private readonly prio: number[] = []
   private next = 0
   /** Queued ids `counts` holds true for. */
   counted = 0
   constructor(
-    private priority: ReadonlyMap<string, number>,
+    private priority: (id: string) => number,
     private readonly counts?: (id: string) => boolean,
   ) {}
   get size(): number {
     return this.ids.length
   }
   /** Re-rank every queued id under `priority`, and every later push. */
-  reprioritize(priority: ReadonlyMap<string, number>): void {
+  reprioritize(priority: (id: string) => number): void {
     this.priority = priority
-    for (let i = 0; i < this.ids.length; i++) this.prio[i] = priority.get(this.ids[i]!) ?? 0
+    for (let i = 0; i < this.ids.length; i++) this.prio[i] = priority(this.ids[i]!)
     for (let i = (this.ids.length >> 1) - 1; i >= 0; i--) this.down(i)
   }
   private down(i: number): void {
@@ -498,7 +596,7 @@ class ReadyHeap {
     if (this.counts?.(id) === true) this.counted++
     this.ids.push(id)
     this.seq.push(seq)
-    this.prio.push(this.priority.get(id) ?? 0)
+    this.prio.push(this.priority(id))
     let i = this.ids.length - 1
     while (i > 0) {
       const parent = (i - 1) >> 1
@@ -530,11 +628,13 @@ class ReadyHeap {
 }
 
 /**
- * The dead server a dependency stands for: itself, or one a group reaches.
- * A group is a name for its deps, and it finished the moment the server
- * was ready, so a task behind it ran against the dead one. Walked with a
- * stack and a seen set: recursion threw `RangeError` on a deep chain of
- * groups, and re-walked a group each path reached it by.
+ * The dead server a dependency stands for: itself, or one a group or a
+ * server reaches. A group is a name for its deps, and it finished the
+ * moment the server was ready, so a task behind it ran against the dead
+ * one; a server stays up on the servers it depends on, so a task behind
+ * `web` runs against the `api` under it too. Walked with a stack and a
+ * seen set: recursion threw `RangeError` on a deep chain of groups, and
+ * re-walked a group each path reached it by.
  */
 export function deadServerBehind(
   nodes: ReadonlyMap<string, TaskNode>,
@@ -549,7 +649,7 @@ export function deadServerBehind(
     seen.add(at)
     if (serverDied(at)) return at
     const n = nodes.get(at)
-    if (n === undefined || !isGroupTask(n)) continue
+    if (n === undefined || (!isGroupTask(n) && n.config.exec?.persistent === undefined)) continue
     // Reversed, so the first dep is walked first, as the order it names them.
     for (let i = n.deps.length - 1; i >= 0; i--) stack.push(n.deps[i]!)
   }
@@ -606,9 +706,9 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
       : options.restoreTier !== undefined && options.restoreTier.size > 0
         ? tieredReverseDepCount(nodes, options.restoreTier)
         : (options.reverseDeps?.() ?? computeReverseDepCount(nodes))
-  const priority: ReadonlyMap<string, number> = options.priorities
+  const priority: (id: string) => number = options.priorities
     ? mergePriorities(baseline, options.priorities)
-    : baseline
+    : (id) => baseline.get(id) ?? 0
 
   // Two ready queues — exec-tier (cache misses + unstable tasks) and
   // restore-tier (confirmed stable local hits). Each is a max-heap keyed by
@@ -627,7 +727,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
   // (`dormant`) until a dependant is demoted, which starts it, or until
   // every dependant has finished, which settles it unspawned. Settled
   // without an outcome: it is not part of the run, as a pruned task is not.
-  // A group between it and its hits is idle with it.
+  // A group or a server between it and its hits is idle with it.
   const idleGroups = new Set<string>()
   const idle = idleServers(nodes, dependents, restoreTier, idleGroups)
   for (const g of idleGroups) idle.add(g)
@@ -684,7 +784,8 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
   // complete.
   // When each queued id became ready; dispatch takes it out.
   const readyAt = new Map<string, number>()
-  const startedAt = Date.now()
+  // Elapsed-time stamps (queue and hold waits), immune to wall clock steps.
+  const startedAt = performance.now()
   for (const node of nodes.values()) {
     if (restoreTier?.has(node.id)) restoreReady.push(node.id)
     else if (node.deps.length === 0) execReady.push(node.id)
@@ -896,7 +997,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
         if (heldRelease.delete(d)) enter(d)
         else if (!inRestoreTier(d)) {
           execReady.push(d)
-          readyAt.set(d, Date.now())
+          readyAt.set(d, performance.now())
         }
       }
     }
@@ -1027,7 +1128,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
             if (hasRoom(id)) {
               if (!admitActive || admits(id)) return id
               // A free worker, refused by the policy: the hold starts now.
-              if (!heldSince.has(id)) heldSince.set(id, Date.now())
+              if (!heldSince.has(id)) heldSince.set(id, performance.now())
             }
             parked.push([id, seq])
           }
@@ -1107,7 +1208,8 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
           continue
         }
 
-        const queuedMs = Date.now() - (readyAt.get(id) ?? Date.now())
+        const readySince = readyAt.get(id)
+        const queuedMs = readySince === undefined ? 0 : Math.round(performance.now() - readySince)
         readyAt.delete(id)
         const settle = settleInPlace(node, upstream)
         let now: TaskOutcome | undefined
@@ -1120,7 +1222,8 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
           }
         }
         if (now !== undefined) {
-          finishOne(id, queuedMs === 0 ? now : { ...now, queuedMs })
+          if (queuedMs !== 0) now.queuedMs = queuedMs
+          finishOne(id, now)
           continue
         }
         const leave = admit(id)
@@ -1128,7 +1231,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
         // tick sees it; the completion callbacks unlist it.
         const untrack = track(id)
         const since = admitActive ? heldSince.get(id) : undefined
-        const heldMs = since === undefined ? 0 : Math.max(1, Date.now() - since)
+        const heldMs = since === undefined ? 0 : Math.max(1, Math.round(performance.now() - since))
         if (since !== undefined) heldSince.delete(id)
         const withHold = (o: TaskOutcome): TaskOutcome =>
           heldMs === 0 && queuedMs === 0
@@ -1177,8 +1280,8 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
             }
             void settled.then(done, () => done())
           },
-          (err: unknown) => {
-            if (err instanceof RestoreDemoted) {
+          (thrown: unknown) => {
+            if (thrown instanceof RestoreDemoted) {
               leave()
               untrack()
               demoted.add(id)
@@ -1186,16 +1289,22 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
                 idle.delete(p)
                 if (dormant.delete(p)) {
                   execReady.push(p)
-                  readyAt.set(p, Date.now())
+                  readyAt.set(p, performance.now())
                 }
               })
               if (pending.get(id) === 0) {
                 execReady.push(id)
-                readyAt.set(id, Date.now())
+                readyAt.set(id, performance.now())
               }
               tick()
               return
             }
+            const err =
+              thrown instanceof RestoreFailed ||
+              thrown instanceof KeyFailed ||
+              thrown instanceof OutputsFailed
+                ? thrown.error
+                : thrown
             const message = thrownMessage(err)
             // After the run's stop a rejection is the stop's doing (a probe
             // it killed, C-65): aborted, as any task it kills, and unsaid.
@@ -1203,9 +1312,12 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
             const outcome: TaskOutcome = withHold({
               node,
               status: stopped ? 'aborted' : 'failed',
-              exitCode: 1,
-              durationMs: 0,
+              exitCode: thrown instanceof OutputsFailed ? thrown.exitCode : 1,
+              durationMs: thrown instanceof OutputsFailed ? thrown.durationMs : 0,
+              ...(thrown instanceof RestoreFailed && !stopped ? { restoreFailed: true } : {}),
             })
+            if (thrown instanceof KeyFailed && !stopped) markKeyFailed(outcome)
+            if (thrown instanceof OutputsFailed && !stopped) markOutputsFailed(outcome, thrown.step)
             leave()
             untrack()
             if (stopped) {
@@ -1220,9 +1332,10 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
             // Out of descriptors is the environment's limit too: a stack
             // naming a file that was fine sent the user after the file.
             if (isUserError(err) || isFsRefusal(err) || isOutOfFds(err)) {
-              const text = isUserError(err)
+              const said = isUserError(err)
                 ? message
                 : `${message} — ${isOutOfFds(err) ? OUT_OF_FDS_HINT : fsRefusalHint(err)}`
+              const text = thrown instanceof KeyFailed ? `cache key not derived: ${said}` : said
               // In a task's own output block, in full: that block is read
               // alone, and "as <task> above" named one printed elsewhere or
               // not at all (2026-10-22). On bare stderr the first is above.
@@ -1290,9 +1403,25 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
           continue
         promoted.add(d)
         restoreReady.push(d)
-        readyAt.set(d, Date.now())
+        readyAt.set(d, performance.now())
+      }
+      // Idle as `idleServers` finds it: through the groups and servers
+      // nobody asked for above it. The servers beneath it are held on the
+      // same keys, so the walk idles them with it; a server already
+      // answered, or never held, keeps its course.
+      if (found.length > 0) {
+        const tier =
+          demoted.size === 0 ? restoreTier : new Set([...restoreTier!].filter(inRestoreTier))
+        const between = new Set<string>()
+        const holdsHere = (s: string): boolean =>
+          s === id || unanswered.has(s) || isGroupTask(nodes.get(s) as TaskNode)
+        for (const s of idleServers(nodes, dependents, tier, between)) if (holdsHere(s)) idle.add(s)
+        for (const g of between)
+          if (holdsHere(g) && !idleGroups.has(g)) {
+            idleGroups.add(g)
+            idle.add(g)
+          }
       }
-      if (dependents.get(id)?.every((d) => inRestoreTier(d)) === true) idle.add(id)
       if (heldReady.delete(id)) execReady.push(id)
       tick()
     }
@@ -1320,10 +1449,11 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
 
 /**
  * Persistent tasks nobody asked for whose every dependant is a restore-tier
- * hit, or a group nobody asked for that only such dependants stand behind:
- * a group runs nothing, so `env: { dependsOn: ['dev'] }` between the server
- * and its hits booted the server on every warm run. Those groups go in
- * `groups`.
+ * hit, or a group or server nobody asked for that only such dependants
+ * stand behind: a group runs nothing, so `env: { dependsOn: ['dev'] }`
+ * between the server and its hits booted the server on every warm run, and
+ * `api` under an idle `web` serves nobody either. Those groups and servers
+ * go in `groups`: the scheduler settles them as it settles a group.
  */
 export function idleServers(
   nodes: ReadonlyMap<string, TaskNode>,
@@ -1334,10 +1464,10 @@ export function idleServers(
   const out = new Set<string>()
   if (restoreTier === undefined || restoreTier.size === 0) return out
   const unasked = (n: TaskNode): boolean => !n.requested && n.surfaced !== true
-  // Per group: whether only hits stand behind it. Post-order on a stack, as
-  // groups nest as deep as the graph.
+  // Per group or server: whether only hits stand behind it. Post-order on a
+  // stack, as groups and servers nest as deep as the graph.
   const spare = new Map<string, boolean>()
-  const spareGroup = (root: string): boolean => {
+  const spareNode = (root: string): boolean => {
     const stack = [root]
     while (stack.length > 0) {
       const id = stack[stack.length - 1]!
@@ -1347,7 +1477,12 @@ export function idleServers(
       }
       const n = nodes.get(id)
       const ds = dependents.get(id)
-      if (n === undefined || !isGroupTask(n) || !unasked(n) || ds === undefined) {
+      if (
+        n === undefined ||
+        (!isGroupTask(n) && n.config.exec?.persistent === undefined) ||
+        !unasked(n) ||
+        ds === undefined
+      ) {
         spare.set(id, false)
         stack.pop()
         continue
@@ -1368,7 +1503,7 @@ export function idleServers(
   for (const n of nodes.values()) {
     if (n.config.exec?.persistent === undefined || !unasked(n)) continue
     const ds = dependents.get(n.id)
-    if (ds === undefined || !ds.every((d) => restoreTier.has(d) || spareGroup(d))) continue
+    if (ds === undefined || !ds.every((d) => restoreTier.has(d) || spareNode(d))) continue
     out.add(n.id)
     if (groups === undefined) continue
     const stack = ds.filter((d) => !restoreTier.has(d))