@vzn/vx 0.0.646 → 0.0.648

package/src/orchestrator/task-hash.ts

@@ -6,6 +6,7 @@ import {
   ABSENT_INPUT,
   absentOr,
   addedInput,
+  behindLink,
   filesToken,
   foldHead,
   type InputListing,
@@ -21,7 +22,16 @@ import {
 } from '../cache/index.js'
 import type { InputFile, TaskInputs } from '../exec/index.js'
 import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
-import { isUserError, relPosix, secretMask, span, UserError, xxh3hex } from '../util/index.js'
+import { GROUP_VIA } from '../history/index.js'
+import {
+  isUserError,
+  keysSorted,
+  relPosix,
+  secretMask,
+  span,
+  UserError,
+  xxh3hex,
+} from '../util/index.js'
 import { expandGroupUpstream, filterUpstreamHashes } from './upstream.js'
 
 /**
@@ -46,6 +56,11 @@ export interface HashCache {
   projectFiles: ProjectFilesCache
   /** Each task's last key by its probe, across runs (the local cache's `FoldMemo`). */
   folds?: FoldMemo | undefined
+  /**
+   * The token of the remembered graph the run's nodes are (graph-memo.ts),
+   * while no plugin or flag has edited them since.
+   */
+  graph?: string | undefined
 }
 
 export function createHashCache(folds?: FoldMemo): HashCache {
@@ -131,15 +146,15 @@ const FOLD_MEMO_VERSION = 'fold-memo-v1'
 /**
  * A task that runs a command and declares no `inputs`: nothing says what
  * it read, so no key can stand for its outputs, and a key that folds it
- * would replay a stale entry (owner, 2026-10-16).
+ * would replay a stale entry (2026-10-16).
  */
 export function isKeyless(task: TaskConfig): boolean {
   return task.exec !== undefined && task.inputs === undefined
 }
 
 /**
- * Drawn once per process, so no run derives another run's keyless keys;
- * on first use, as the browser playground loads this module with no `crypto`.
+ * Drawn once per process, on first use, so no run derives another run's
+ * keyless keys.
  */
 let keylessSalt: string | undefined
 
@@ -159,6 +174,12 @@ export interface InputFact {
   path: string
   digest: string
   since: number
+  /**
+   * For a link, the content behind it (`behindLink`), which the key folds
+   * after the link's own target string. An edit there leaves the link
+   * untouched, so the re-check compares this rather than the link's ctime.
+   */
+  behind?: string
 }
 
 /**
@@ -180,11 +201,21 @@ export async function describeTaskInputs(args: ComputeHashArgs): Promise<{
 }> {
   const hashedAt = Date.now()
   const { input, listings } = await resolveKeyInput(args)
-  const hash = await args.cache.key(input)
   const sorted = [...input.inputFiles].sort()
   const digests = await Promise.all(
     sorted.map((f) => input.fileHashes?.get(f) ?? args.cache.hashFile(f).catch(absentOr)),
   )
+  // Learned BEFORE the key folds it: an edit in between then reads as a
+  // move at the re-check (a withheld save), never as content the key
+  // did not fold matching it (a stale entry).
+  const hashFile = (f: string): Promise<string> => args.cache.hashFile(f)
+  const behind = new Map<string, string>()
+  await Promise.all(
+    sorted.map(async (f, i) => {
+      if (digests[i]!.startsWith('120000:')) behind.set(f, await behindLink(f, hashFile))
+    }),
+  )
+  const hash = await args.cache.key(input)
   // A file gone since the enumeration is no input: the task will not read it.
   const files: InputFile[] = sorted.flatMap((f, i) =>
     digests[i] === ABSENT_INPUT
@@ -192,11 +223,16 @@ export async function describeTaskInputs(args: ComputeHashArgs): Promise<{
       : [{ path: relPosix(input.workspaceRoot, f), digest: digests[i]! }],
   )
   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,
-  }))
+  const facts: InputFact[] = sorted.map((f, i) => {
+    const fact: InputFact = {
+      path: f,
+      digest: digests[i]!,
+      since: input.fileHashes?.has(f) === true ? indexedAt : hashedAt,
+    }
+    const linked = behind.get(f)
+    if (linked !== undefined) fact.behind = linked
+    return fact
+  })
   // 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
@@ -260,7 +296,8 @@ export async function describeTaskInputs(args: ComputeHashArgs): Promise<{
  * 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).
+ * may write the file ran until then (command-windows.ts). A link's content
+ * behind it (`InputFact.behind`) is followed again and compared.
  */
 export async function movedInput(
   facts: readonly InputFact[],
@@ -294,6 +331,12 @@ export async function movedInput(
     const now = await cache.hashFile(f.path).catch(() => undefined)
     if (now !== f.digest) return f.path
   }
+  // What a link points to changes without touching the link: each is
+  // followed again (links are rare, so a task without one pays nothing).
+  const hashFile = (file: string): Promise<string> => cache.hashFile(file)
+  for (const f of facts) {
+    if (f.behind !== undefined && (await behindLink(f.path, hashFile)) !== f.behind) return f.path
+  }
   return undefined
 }
 
@@ -358,6 +401,24 @@ async function resolveKeyInput(
   const upstreamHashes = upstreamPairs.map(([, hash]) => hash)
   // hash → upstream task id, for capture-row naming only (not folded).
   const upstreamIds = new Map(upstreamPairs.map(([id, hash]) => [hash, id]))
+  // A group records no run and keeps no fingerprints, so `vx why` could not
+  // see past one: each folded group's members are captured as rows of their
+  // own, named through it. Rows only, never folded: the group's hash already
+  // folds theirs.
+  if (args.captureInto !== undefined) {
+    const folded = new Set(upstreamPairs.map(([id]) => id))
+    for (const g of args.upstream) {
+      if (g.groupUpstream === undefined || !folded.has(g.node.id)) continue
+      for (const m of expandGroupUpstream(g.groupUpstream)) {
+        if (m.hash === undefined) continue
+        args.captureInto.push({
+          kind: 'upstream',
+          name: `${g.node.id}${GROUP_VIA}${m.node.id}`,
+          hash: m.hash,
+        })
+      }
+    }
+  }
   // The DEPENDENCY closure, groups expanded — for the executor's input root.
   // Deliberately NOT the filtered set above: `inputs.tasks` says which
   // upstream KEYS this task's key folds, and what a task may READ is
@@ -403,6 +464,7 @@ async function resolveKeyInput(
     forwardArgs: effectiveForwardArgs,
     ...(fileHashes !== undefined ? { fileHashes } : {}),
     ...(args.node.keyParts !== undefined ? { pluginParts: args.node.keyParts } : {}),
+    ...(args.node.platform !== undefined ? { platform: args.node.platform } : {}),
     ...(args.captureInto !== undefined ? { captureInto: args.captureInto } : {}),
   }
   return { input, listings: resolved.listings }
@@ -454,9 +516,12 @@ export function hashTaskConfig(cfg: TaskConfig, hashCache?: HashCache): string {
  * would bump CACHE_VERSION.
  */
 function hashableConfig(cfg: TaskConfig): unknown {
-  if (cfg.exec?.remote === undefined) return cfg
+  // 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 { ...cfg, exec: execRest }
+  return keysSorted({ ...cfg, exec: execRest })
 }
 
 /**

package/src/orchestrator/task-log-buffer.ts

@@ -105,7 +105,7 @@ function budgetCost(chars: number, chunkCount: number): number {
 
 /**
  * Bounded per-run capture. `append` keeps a chunk LIST + running char count per
- * task, evicting whole chunks from the head past `TASK_LOG_TAIL_CHARS` — no
+ * task, evicting from the head past `TASK_LOG_TAIL_CHARS` — no
  * string concatenation until `drain`, so a cache-hit replay (one big chunk) is
  * one array push, zero copies. `finish` decides retention; `drain` emits the
  * bundle, failures first.
@@ -115,6 +115,16 @@ export class TaskLogBuffer {
   private readonly retained = new Map<string, Retained>()
   private retainedChars = 0
   private seq = 0
+  /**
+   * Retained entries in eviction order, kept as they arrive: successes are
+   * stubbed from `successHead` on (oldest first), failures from the end
+   * (newest first). An entry since stubbed, taken or replaced is skipped
+   * where it lies. A sort of every entry per finish made a run past the
+   * budget quadratic: 40,000 tasks took 17 s in a sink's `onRecord`.
+   */
+  private readonly successes: Retained[] = []
+  private successHead = 0
+  private failures: Retained[] = []
 
   append(taskId: string, chunk: string): void {
     if (chunk.length === 0) return
@@ -126,24 +136,27 @@ export class TaskLogBuffer {
     acc.chunks.push(chunk)
     acc.chars += chunk.length
     acc.charsFull += chunk.length
-    // Evict whole chunks from the head until under the per-task tail cap. A
-    // single over-cap chunk is sliced to its tail (the only place we copy).
-    while (acc.chars > TASK_LOG_TAIL_CHARS && acc.chunks.length > 1) {
-      const dropped = acc.chunks.shift()!
-      acc.chars -= dropped.length
-      acc.truncatedHeadChars += dropped.length
-    }
-    if (acc.chars > TASK_LOG_TAIL_CHARS && acc.chunks.length === 1) {
-      const only = acc.chunks[0]!
-      let start = only.length - TASK_LOG_TAIL_CHARS
+    // Evict whole chunks from the head until under the per-task tail cap;
+    // the one that straddles the cap is sliced to what still fits (the only
+    // place we copy). Dropped whole, a 128 KiB chunk and a 7-char one after
+    // it kept the 7 chars alone.
+    while (acc.chars > TASK_LOG_TAIL_CHARS) {
+      const head = acc.chunks[0]!
+      const excess = acc.chars - TASK_LOG_TAIL_CHARS
+      if (head.length <= excess) {
+        acc.chunks.shift()
+        acc.chars -= head.length
+        acc.truncatedHeadChars += head.length
+        continue
+      }
+      let start = excess
       // A cut between a surrogate pair would open the tail on a lone low
       // surrogate, which a sink's UTF-8 encode turns into U+FFFD.
-      const first = only.charCodeAt(start)
+      const first = head.charCodeAt(start)
       if (first >= 0xdc00 && first <= 0xdfff) start++
-      const keep = only.slice(start)
-      acc.truncatedHeadChars += only.length - keep.length
-      acc.chunks[0] = keep
-      acc.chars = keep.length
+      acc.chunks[0] = head.slice(start)
+      acc.chars -= start
+      acc.truncatedHeadChars += start
     }
   }
 
@@ -180,9 +193,32 @@ export class TaskLogBuffer {
     if (prior !== undefined) this.retainedChars -= budgetCost(prior.chars, prior.chunks.length)
     this.retained.set(taskId, entry)
     this.retainedChars += budgetCost(entry.chars, entry.chunks.length)
+    ;(status === 'success' ? this.successes : this.failures).push(entry)
+    this.compact()
     this.evictToBudget()
   }
 
+  /** Whether `e` may still be stubbed: retained as it is, content and all. */
+  private evictable(e: Retained): boolean {
+    return e.chars > 0 && this.retained.get(e.taskId) === e
+  }
+
+  /**
+   * Drop what eviction would only skip, once the queues hold twice what is
+   * retained: a sink that takes every entry (`takeEntry`) never evicts, and
+   * its queues would grow by a task each. Amortized constant per finish.
+   */
+  private compact(): void {
+    const room = 2 * this.retained.size + 1024
+    if (this.successes.length - this.successHead > room || this.successHead > room) {
+      const live = this.successes.slice(this.successHead).filter((e) => this.evictable(e))
+      this.successes.length = 0
+      this.successes.push(...live)
+      this.successHead = 0
+    }
+    if (this.failures.length > room) this.failures = this.failures.filter((e) => this.evictable(e))
+  }
+
   /**
    * Take ONE finished task's retained tail as a wire entry, removing it from
    * the buffer (so a later `drain` won't re-ship it). Used by per-task
@@ -249,7 +285,7 @@ export class TaskLogBuffer {
   /**
    * Evict until `retainedChars <= RUN_LOG_BUDGET_CHARS`. Successes go first
    * (oldest by seq); only when failures ALONE still exceed the budget do the
-   * oldest failures go — a failure is never dropped to keep a success.
+   * newest failures go — a failure is never dropped to keep a success.
    *
    * An evicted task is degraded to a STUB (no content, `truncatedHeadChars`
    * = everything it emitted) rather than removed. Dropping the entry makes a
@@ -269,25 +305,25 @@ export class TaskLogBuffer {
    * sees it.
    */
   private evictToBudget(): void {
-    if (this.retainedChars <= RUN_LOG_BUDGET_CHARS) return
-    const order = [...this.retained.values()].sort((a, b) => {
-      const sa = a.status === 'success' ? 0 : 1
-      const sb = b.status === 'success' ? 0 : 1
-      if (sa !== sb) return sa - sb // successes are dropped first, always
-      // Within a tier the tiebreak DIFFERS by status, and the failed one is
-      // the point: when failures alone blow the budget, the FIRST failure is
-      // usually the root cause and the later ones its cascade, so it must be
-      // the last thing stubbed. Successes keep oldest-first — none of them
-      // is more interesting than another, and recency is the better guess.
-      return a.status === 'failed' ? b.seq - a.seq : a.seq - b.seq
-    })
-    for (const e of order) {
-      if (this.retainedChars <= RUN_LOG_BUDGET_CHARS) break
-      if (e.chars === 0) continue // already a stub — frees nothing
-      this.retainedChars -= budgetCost(e.chars, e.chunks.length)
-      e.truncatedHeadChars += e.chars
-      e.chunks = []
-      e.chars = 0
+    // Successes are dropped first, always, and keep oldest-first: none of
+    // them is more interesting than another, and recency is the better
+    // guess. Failures go newest-first: when failures alone blow the budget,
+    // the FIRST failure is usually the root cause and the later ones its
+    // cascade, so it must be the last thing stubbed.
+    while (this.retainedChars > RUN_LOG_BUDGET_CHARS && this.successHead < this.successes.length) {
+      const e = this.successes[this.successHead++]!
+      if (this.evictable(e)) this.stub(e)
+    }
+    while (this.retainedChars > RUN_LOG_BUDGET_CHARS && this.failures.length > 0) {
+      const e = this.failures.pop()!
+      if (this.evictable(e)) this.stub(e)
     }
   }
+
+  private stub(e: Retained): void {
+    this.retainedChars -= budgetCost(e.chars, e.chunks.length)
+    e.truncatedHeadChars += e.chars
+    e.chunks = []
+    e.chars = 0
+  }
 }

package/src/orchestrator/task-process.ts

@@ -74,6 +74,7 @@ export function taskEnv(
     define: step.env?.define ?? {},
     source: process.env,
     binPaths: bins,
+    workspaceRoot,
   })
   env[VX_RUN_WORKSPACE_ENV] = workspaceRoot
   env[VX_RUN_TASK_ENV] = node.id
@@ -91,7 +92,11 @@ export function taskTimeoutMs(step: ExecConfig): number | undefined {
 }
 
 /** Persistent task `node` as a `servers` executor starts it: no forwarded args, which a dependency never gets. */
-export function serverSpec(node: TaskNode, workspaceRoot: string): ServerSpec {
+export function serverSpec(
+  node: TaskNode,
+  workspaceRoot: string,
+  nested: readonly string[],
+): ServerSpec {
   const step = node.config.exec!
   const timeoutMs = taskTimeoutMs(step)
   const readyWhen = step.persistent?.readyWhen
@@ -102,6 +107,7 @@ export function serverSpec(node: TaskNode, workspaceRoot: string): ServerSpec {
     env: taskEnv(node, step, workspaceRoot),
     ...(readyWhen === undefined ? {} : { readyWhen }),
     ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    ...(step.sandbox === undefined ? {} : { sandbox: { config: step.sandbox, nested } }),
   }
 }
 

package/src/orchestrator/telemetry-host.ts

@@ -17,10 +17,11 @@ import type {
   RunContextRecord,
   RunSummaryRecord,
   TelemetryContext,
+  TelemetryRecord,
   TelemetrySink,
   TreeLoad,
 } from './telemetry.js'
-import { settleWithin, teardownTimeoutMs } from '../util/index.js'
+import { settleWithin, teardownTimeoutMs, thrownMessage } from '../util/index.js'
 import { createTelemetrySource } from './telemetry.js'
 import type { VxPlugin } from './plugin.js'
 
@@ -36,6 +37,16 @@ export interface TelemetryHandle {
   readonly track?: (taskId: string, pid: number) => () => TreeLoad | undefined
 }
 
+// Every kind once: a kind added to `TelemetryRecord` fails to compile here.
+const RECORD_KINDS: Record<TelemetryRecord['kind'], true> = {
+  'run.start': true,
+  'task.start': true,
+  'task.log': true,
+  'task.sample': true,
+  'task.end': true,
+  'run.end': true,
+}
+
 /** Reject anything that is not sink-shaped, naming what arrived. */
 function checkSink(sink: unknown): TelemetrySink {
   if (typeof sink !== 'object' || sink === null) {
@@ -45,6 +56,15 @@ function checkSink(sink: unknown): TelemetrySink {
   if (wants !== undefined && !Array.isArray(wants)) {
     throw new Error(`telemetry sink 'wants' must be an array, got ${typeof wants}`)
   }
+  // A misspelt kind (`task.logs`) was a sink that never heard it, with no word.
+  const unknown = (wants as readonly unknown[] | undefined)?.find(
+    (k) => typeof k !== 'string' || !Object.hasOwn(RECORD_KINDS, k),
+  )
+  if (unknown !== undefined) {
+    throw new Error(
+      `telemetry sink 'wants' names ${typeof unknown === 'string' ? JSON.stringify(unknown) : typeof unknown}, which is no record kind (${Object.keys(RECORD_KINDS).join(', ')})`,
+    )
+  }
   // Every handler is optional, so `{ nope: true }` was a valid sink that
   // subscribed to the bus and heard nothing — the plugin was "on" and did
   // nothing. Refused here, which the caller turns into the same warning
@@ -102,7 +122,7 @@ export async function subscribeTelemetry(
       accepted = list.map((sink) => checkSink(sink))
     } catch (err) {
       ctx.warn(
-        `[vx] plugin '${plugin.name}' telemetry failed to initialize; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+        `[vx] plugin '${plugin.name}' telemetry failed to initialize; disabled for this run: ${thrownMessage(err)}`,
       )
       continue
     }

package/src/orchestrator/telemetry.ts

@@ -27,7 +27,13 @@ import {
   type TaskOutcome,
   type TaskStatus,
 } from '../graph/index.js'
-import { maskedCommand, settleWithin, teardownTimeoutMs } from '../util/index.js'
+import {
+  maskedCommand,
+  settleWithin,
+  stageTimes,
+  teardownTimeoutMs,
+  thrownMessage,
+} from '../util/index.js'
 import type { RunEvent, RunEventSubscriber } from '../report/index.js'
 
 /** Bumped when the record shape changes. Readers MUST check `v`. */
@@ -114,6 +120,10 @@ export interface TaskTelemetry {
   /** Executor-reported placement (a worker id) — absent for local runs.
    *  Additive-optional, no schema bump (the `attempts` precedent). */
   where?: string
+  /** A persistent task each dependant's executor started where that ran:
+   *  part of those runs, never an execution of its own (2026-10-23:
+   *  nothing runs on a distributed run's orchestrator). Additive-optional. */
+  carried?: true
   /** `'deferred'` when the outputs stayed remote (`--cache-download=none`).
    *  Additive-optional, same no-bump precedent as `where`. */
   outputs?: 'deferred'
@@ -127,6 +137,8 @@ export interface TaskTelemetry {
    * fail-fast skip and on every other status. Additive (schema stays 2).
    */
   blockedBy?: string
+  /** On a `skipped` task: its `exec.platforms` leave out the machine that ran the run. Additive. */
+  otherPlatform?: { readonly needs: readonly string[]; readonly host: string }
   /** On a `failed` task: vx's own `timeout` killed it (exit 143 is the deadline, not a signal). Additive. */
   timedOut?: true
   /** On a sandboxed task: how many declared-boundary violations the sandbox recorded (a failure on its own). Additive. */
@@ -188,6 +200,10 @@ export type TelemetryRecord =
       /** The run's canonical start (epoch ms) — equals the summary's
        *  `startedAt`; a sink derives per-task timing from it during the run. */
       startedAt: number
+      /** Where the run's stage table begins (epoch ms), the first stage's
+       *  start: at or before `startedAt`. A sink that draws the stages
+       *  starts the run here. Additive. */
+      originAt?: number
     }
   | {
       v: number
@@ -280,6 +296,11 @@ export interface RunSummaryRecord {
    * executor reports any. Additive.
    */
   machines?: readonly MachineReport[]
+  /**
+   * The run's end had an executor placed its tasks perfectly
+   * (`TaskExecutor.idealMs`), beside `totalDurationMs`. Additive.
+   */
+  idealMs?: number
 }
 
 /** One stage of a run, a wall window in epoch ms. */
@@ -312,6 +333,7 @@ export function assembleRunSummary(
     stages?: readonly RunStage[]
     uploads?: { count: number; bytes: number; ms: number; failed: number }
     machines?: readonly MachineReport[]
+    idealMs?: number | undefined
   },
 ): RunSummaryRecord {
   let failedCount = 0
@@ -353,6 +375,7 @@ export function assembleRunSummary(
     ...(timing.machines !== undefined && timing.machines.length > 0
       ? { machines: timing.machines }
       : {}),
+    ...(timing.idealMs !== undefined ? { idealMs: timing.idealMs } : {}),
   }
 }
 
@@ -427,6 +450,8 @@ export interface TreeLoad {
 
 /** How often a running task's process tree is sampled. */
 const SAMPLE_MS = 1000
+/** How long an aborted flush may take to end its own requests. */
+const ABORT_GRACE_MS = 250
 
 /** Call `fn` every `ms` until the returned stop is called. */
 type Every = (ms: number, fn: () => Promise<void>) => () => void
@@ -489,7 +514,7 @@ export function createTelemetrySource(args: {
     if (disabled.has(sink)) return
     disabled.add(sink)
     warn?.(
-      `[vx] telemetry sink '${label(sink)}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+      `[vx] telemetry sink '${label(sink)}' threw in ${hook}; disabled for this run: ${thrownMessage(err)}`,
     )
   }
   // Precompute which sinks want each kind, so per-event fan-out is a plain
@@ -599,6 +624,7 @@ export function createTelemetrySource(args: {
           total: event.info.total,
           ts,
           startedAt: event.info.startedAtMs ?? ts,
+          ...originOf(),
         })
         return
       case 'task:start': {
@@ -682,28 +708,26 @@ export function createTelemetrySource(args: {
       // accessed_at bumps and every later plugin's teardown lost with it.
       // Sinks race concurrently, so each still gets the whole budget.
       const deadline = new AbortController()
-      const settled = await settleWithin(
-        Promise.all(
-          sinks.map(async (sink) => {
-            if (disabled.has(sink) || sink.flush === undefined) return
-            try {
-              await step(`${args.owners?.get(sink) ?? label(sink)}:telemetry`, () =>
-                sink.flush!(deadline.signal),
-              )
-            } catch (err) {
-              // A flush failure can never break the run — but it still costs
-              // this sink its export, so say so rather than dropping it.
-              warn?.(
-                `[vx] telemetry sink '${label(sink)}' failed to flush: ${err instanceof Error ? err.message : String(err)}`,
-              )
-            }
-          }),
-        ),
-        ms,
+      const all = Promise.all(
+        sinks.map(async (sink) => {
+          if (disabled.has(sink) || sink.flush === undefined) return
+          try {
+            await step(`${args.owners?.get(sink) ?? label(sink)}:telemetry`, () =>
+              sink.flush!(deadline.signal),
+            )
+          } catch (err) {
+            // A flush failure can never break the run — but it still costs
+            // this sink its export, so say so rather than dropping it.
+            warn?.(`[vx] telemetry sink '${label(sink)}' failed to flush: ${thrownMessage(err)}`)
+          }
+        }),
       )
-      if (!settled) {
+      if (!(await settleWithin(all, ms))) {
         deadline.abort(new Error(`telemetry flush deadline (${ms}ms)`))
         warn?.(`[vx] telemetry flush timed out after ${ms}ms; buffered records lost`)
+        // A sink told of the abort says what it lost as its request ends; the
+        // run ended first and that line was lost (vx-otel, on CI). Briefly.
+        await settleWithin(all, ABORT_GRACE_MS)
       }
     },
   }
@@ -747,9 +771,11 @@ export function taskTelemetryOf(o: TaskOutcome): TaskTelemetry {
   if (o.cpuMs !== undefined) t.cpuMs = o.cpuMs
   if (o.peakRssBytes !== undefined) t.peakRssBytes = o.peakRssBytes
   if (o.where !== undefined) t.where = o.where
+  if (o.carried === true) t.carried = true
   if (o.outputs !== undefined) t.outputs = o.outputs
   if (o.attempts !== undefined) t.attempts = o.attempts
   if (o.blockedBy !== undefined) t.blockedBy = o.blockedBy
+  if (o.otherPlatform !== undefined) t.otherPlatform = o.otherPlatform
   if (o.timedOut === true) t.timedOut = true
   if (o.sandboxViolations !== undefined) t.sandboxViolations = o.sandboxViolations
   if (o.notReady !== undefined) t.notReady = o.notReady
@@ -773,3 +799,9 @@ export function taskTelemetryOf(o: TaskOutcome): TaskTelemetry {
   if (o.wallclockEndNs !== undefined) t.wallclockEndNs = o.wallclockEndNs.toString()
   return t
 }
+
+/** The stage table's start, when a stage was marked. */
+function originOf(): { originAt?: number } {
+  const first = stageTimes()[0]
+  return first === undefined ? {} : { originAt: first.startedAt }
+}

package/src/orchestrator/upstream.ts

@@ -24,6 +24,21 @@ export function keyUpstream(node: TaskNode, upstream: TaskOutcome[]): TaskOutcom
   return node.excludedUpstream === undefined ? keyed : [...keyed, ...node.excludedUpstream]
 }
 
+/** The ids some task of the run depends on; the rest run with `noDependants`. */
+export function dependedOn(nodes: Iterable<TaskNode>): Set<string> {
+  const ids = new Set<string>()
+  for (const n of nodes) for (const d of n.deps) ids.add(d)
+  return ids
+}
+
+/**
+ * A server's key is read only by a dependant (A-17), so with none in the
+ * run it derives none (`noDependants`), and the plan must not show one.
+ */
+export function keylessServer(node: TaskNode, depended: ReadonlySet<string>): boolean {
+  return node.config.exec?.persistent !== undefined && !depended.has(node.id)
+}
+
 /** A dependency as a key reads it: only `node` and `hash` matter. */
 export function keyedOutcome(node: TaskNode, hash: string | undefined): TaskOutcome {
   const o: TaskOutcome = { node, status: 'success', exitCode: 0, durationMs: 0 }