@runuai/host 0.9.150 → 0.9.151

package/lib/standard-image.ts

@@ -23,9 +23,14 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
-  MAINTENANCE_CONTAINER_LABEL,
-  recycleAppleRuntimeServices,
-} from "./apple-runtime-recycle";
+  appleOneOffNeedsWatch,
+  appleOneOffRunArgs,
+  askRuntimeOwnerOnce,
+  newAppleOneOff,
+  settleAppleOneOff,
+  watchAppleOneOff,
+} from "./apple-one-off";
+import { recycleAppleRuntimeServices, type AppleRecycleOutcome } from "./apple-runtime-recycle";
 import { detectEngine } from "./engines";
 import { hasStoredEngineAccounts } from "./engine-accounts";
 import {
@@ -34,6 +39,7 @@ import {
   containerRuntimeStandardAssetsRoot,
   containerRuntimeStandardImageRoot,
   pinnedContainerRuntimeProvider,
+  requestContainerRuntimeRecheck,
 } from "./container-runtime";
 import { KeyedPromiseTail } from "./keyed-promise-tail";
 import {
@@ -249,17 +255,59 @@ function selectedEngine(): { command: string; apple: boolean } {
   return { command: "docker", apple: false };
 }
 
-/** Run a command to completion, capturing stdio. Never rejects and never
- * waits forever: standard-image maintenance is an activation prerequisite,
- * so an unbounded Docker/npm child would strand the entire host in checking. */
+/** The most bytes of each stream a standard-image command keeps; the rest is
+ *  read and dropped, so a child that writes without end holds no more of the
+ *  runner's memory than this. */
+const RUN_CAPTURE_BYTES = 8 * 1024 * 1024;
+
+/** One stream, kept to at most RUN_CAPTURE_BYTES of its encoded bytes; the
+ *  runner's own diagnostics go through the same bound. */
+class BoundedCapture {
+  #chunks: Buffer[] = [];
+  #bytes = 0;
+  #lastByte: number | null = null;
+
+  add(chunk: Buffer | string): void {
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+    if (bytes.length === 0 || this.#bytes >= RUN_CAPTURE_BYTES) return;
+    const kept = bytes.subarray(0, RUN_CAPTURE_BYTES - this.#bytes);
+    this.#chunks.push(kept);
+    this.#bytes += kept.length;
+    this.#lastByte = kept[kept.length - 1]!;
+  }
+
+  /** A line of the runner's own, on a line of its own. */
+  addLine(line: string): void {
+    this.add(`${this.#lastByte !== null && this.#lastByte !== 0x0a ? "\n" : ""}${line}`);
+  }
+
+  /** What it kept, as text that keeps the bound too: a character the
+   *  bound cut, or bytes that are not UTF-8, decode to a three-byte
+   *  replacement character, so past the bound the text ends at its last
+   *  whole character. */
+  text(): string {
+    const text = Buffer.concat(this.#chunks).toString("utf8");
+    if (Buffer.byteLength(text, "utf8") <= RUN_CAPTURE_BYTES) return text;
+    const encoded = Buffer.from(text, "utf8");
+    let end = RUN_CAPTURE_BYTES;
+    // Back to the first byte of the character the bound cuts.
+    while (end > 0 && (encoded[end]! & 0xc0) === 0x80) end -= 1;
+    return encoded.subarray(0, end).toString("utf8");
+  }
+}
+
+/** Run a command to completion, capturing stdio, at most RUN_CAPTURE_BYTES
+ * of each. Never rejects and never waits forever: standard-image maintenance
+ * is an activation prerequisite, so an unbounded Docker/npm child would
+ * strand the entire host in checking. */
 function run(
   command: string,
   args: string[],
   timeoutMs = SHORT_DOCKER_TIMEOUT_MS,
 ): Promise<RunResult> {
   return new Promise<RunResult>((resolveRun) => {
-    let stdout = "";
-    let stderr = "";
+    const stdout = new BoundedCapture();
+    const stderr = new BoundedCapture();
     let settled = false;
     let killTimer: NodeJS.Timeout | null = null;
     const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -268,10 +316,10 @@ function run(
       settled = true;
       clearTimeout(timeoutTimer);
       if (killTimer) clearTimeout(killTimer);
-      resolveRun({ code, stdout, stderr });
+      resolveRun({ code, stdout: stdout.text(), stderr: stderr.text() });
     };
     const timeoutTimer = setTimeout(() => {
-      stderr += `${stderr && !stderr.endsWith("\n") ? "\n" : ""}${command} timed out after ${timeoutMs}ms`;
+      stderr.addLine(`${command} timed out after ${timeoutMs}ms`);
       child.kill("SIGTERM");
       killTimer = setTimeout(() => {
         child.kill("SIGKILL");
@@ -283,16 +331,14 @@ function run(
       killTimer.unref();
     }, timeoutMs);
     timeoutTimer.unref();
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk: string) => {
-      stdout += chunk;
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout.add(chunk);
     });
-    child.stderr?.on("data", (chunk: string) => {
-      stderr += chunk;
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr.add(chunk);
     });
     child.on("error", (err: Error) => {
-      stderr += err.message;
+      stderr.add(err.message);
       settle(null);
     });
     child.on("close", (code) => {
@@ -304,8 +350,6 @@ function run(
 /** Narrow process-level seam for the timeout regression test. */
 export const runStandardImageCommandForTest = run;
 
-let maintenanceContainerSeq = 0;
-
 /** How long a maintenance run may sit without its container reaching
  * `running` before the wedge sensor passes judgment. Long HEALTHY operations
  * (reconcile's npm installs, the seed copy) are past `running` within
@@ -385,35 +429,57 @@ async function appleWedgeVerdict(
  * at start time (the exclusive-volume attach, most commonly) leaves a
  * created-never-started container behind, and those corpses wedge the
  * runtime's apiserver (observed live 2026-08-16, twice: run/delete hang
- * while list still answers). Naming the container makes the corpse
- * addressable, so a failed run is followed by a bounded best-effort
- * `delete --force` of that exact name. Docker's `--rm` is reliable and its
+ * while list still answers). So the container is named and marked Uai's
+ * (apple-one-off.ts), and a failed run is settled: its container proven
+ * gone, deleted until it is, the runtime's services recycled when it will
+ * not go; a run whose client never reported its end is watched a while
+ * longer for a container created late. Docker's `--rm` is reliable and its
  * containers are not corpse-prone, so the Docker path passes through.
  *
  * Every apple run doubles as the WEDGE SENSOR (the owner's "this needs to
  * be automatic"): if the container has not reached `running` after the
- * probe delay while `list` still answers, the runtime services are recycled
- * in place (see apple-runtime-recycle.ts) and the run reports a distinctive
- * retryable failure — the activation retry loop then re-runs maintenance
- * against the fresh runtime.
+ * probe delay while `list` still answers, the run reports a distinctive
+ * retryable failure. Within the runtime's current activation, the runtime
+ * services are first recycled in place (see apple-runtime-recycle.ts), and
+ * the activation recovers every task after, its retry loop re-running
+ * maintenance against the fresh runtime. Within an activation that is no
+ * longer current, nothing restarts the runtime: the current one is coming,
+ * with its own maintenance and recovery. Outside any (the hourly pass, a
+ * task's start, an engine's sign-in), nothing restarts the runtime either:
+ * its owner is asked to recheck it, whose activation does (#p2jdax).
  */
 async function runMaintenanceContainer(
   engine: { command: string; apple: boolean },
   purpose: string,
   argsAfterRun: string[],
   timeoutMs: number,
+  activation: ActivationIsCurrent | null,
 ): Promise<RunResult> {
   if (!engine.apple) {
     return run(engine.command, ["run", ...argsAfterRun], timeoutMs);
   }
-  maintenanceContainerSeq += 1;
-  const name = `uai-maint-${purpose}-${process.pid}-${maintenanceContainerSeq}`;
+  const oneOff = newAppleOneOff(purpose);
+  const { name } = oneOff;
+  const cli = (args: string[], cliTimeoutMs: number) => run(engine.command, args, cliTimeoutMs);
+  // The remedy outside activation, and for a watch (which outlives any
+  // activation): ask the runtime's owner, once for this run.
+  const askOwner = askRuntimeOwnerOnce(
+    requestContainerRuntimeRecheck,
+    `maintenance container ${name} found the Apple runtime wedged, or could not be removed`,
+  );
+  // The remedy within an activation: the runtime's services restarted, only
+  // while that activation is current.
+  const notCurrent = "its activation is no longer the current one";
+  const restart = async (): Promise<AppleRecycleOutcome> =>
+    activation?.() ? recycleAppleRuntimeServices({ cli }) : { recycled: false, reason: notCurrent };
+  let wedgedUnremedied = false;
   let runSettled = false;
   const running = run(
     engine.command,
-    // The ownership label is what authorizes the recycle sweep (and only the
-    // sweep) to delete this container later — a name alone is forgeable.
-    ["run", "--name", name, "-l", `${MAINTENANCE_CONTAINER_LABEL}=1`, ...argsAfterRun],
+    // Its labels are what authorize deleting this container later (here, by
+    // its run's token; in the recycle sweep, by Uai's) — a name alone is
+    // forgeable.
+    ["run", ...appleOneOffRunArgs(oneOff), ...argsAfterRun],
     timeoutMs,
   ).then((outcome) => {
     runSettled = true;
@@ -424,9 +490,16 @@ async function runMaintenanceContainer(
     if (runSettled) return null;
     if (!(await appleWedgeVerdict(engine, name))) return null;
     if (runSettled) return null;
-    const outcome = await recycleAppleRuntimeServices({
-      cli: (args, cliTimeoutMs) => run(engine.command, args, cliTimeoutMs),
-    });
+    if (activation === null || !activation()) {
+      wedgedUnremedied = true;
+      const reason = activation === null ? (await askOwner()).reason : notCurrent;
+      return {
+        code: null,
+        stdout: "",
+        stderr: `apple container runtime is wedged; ${reason} — retry this operation`,
+      };
+    }
+    const outcome = await restart();
     // The hung CLI client may exit once its apiserver dies; give it a short
     // grace so a real result wins, then synthesize the retryable failure.
     const graced = await Promise.race([
@@ -447,61 +520,26 @@ async function runMaintenanceContainer(
     sensed.then((synthesized) => synthesized ?? running),
   ]);
   if (result.code !== 0) {
+    const watched = { cli, recycle: askOwner };
+    if (wedgedUnremedied) {
+      // Nothing can be deleted until a current activation has restarted the
+      // runtime: its name is only watched, and this pass (which that
+      // activation's own may wait behind) ends now.
+      void watchAppleOneOff(watched, oneOff, { lateCreation: true });
+      return result;
+    }
     // The run may have failed BECAUSE this generated name already existed —
     // then the container is not ours and the ownership label was never
-    // applied (review 2026-08-18 round 3). Deletion requires a positive
-    // label proof; an absent container is done; anything uncertain is left
-    // untouched and reported.
-    const inspected = await run(engine.command, ["inspect", name], 15_000);
-    let verdict: "ours" | "absent" | "foreign" | "unknown" = "unknown";
-    if (
-      inspected.code !== 0 &&
-      inspected.stdout.trim() === "" &&
-      inspected.stderr
-        .split("\n")
-        .some((line) => line.trim() === `Error: container not found: ${name}`)
-    ) {
-      verdict = "absent";
-    } else if (inspected.code === 0) {
-      try {
-        const parsed = JSON.parse(inspected.stdout) as Array<{
-          id?: unknown;
-          configuration?: { labels?: Record<string, unknown> };
-        }>;
-        if (Array.isArray(parsed) && parsed.length === 1 && parsed[0]?.id === name) {
-          verdict =
-            parsed[0]?.configuration?.labels?.[MAINTENANCE_CONTAINER_LABEL] === "1"
-              ? "ours"
-              : "foreign";
-        }
-      } catch {
-        verdict = "unknown";
-      }
-    }
-    if (verdict === "ours") {
-      const removed = await run(
-        engine.command,
-        ["delete", "--force", name],
-        30_000,
-      );
-      if (removed.code !== 0) {
-        console.warn(
-          `[host-agent] could not remove maintenance container ${name} after a ` +
-            `failed run (exit ${removed.code ?? "spawn"}); a created-never-started ` +
-            `container can wedge the Apple runtime. ${removed.stderr.trim().slice(0, 200)}`,
-        );
-      }
-    } else if (verdict === "foreign") {
-      console.warn(
-        `[host-agent] a container named ${name} exists WITHOUT Uai's maintenance ` +
-          "ownership label — the failed run likely collided with it; leaving it untouched",
-      );
-    } else if (verdict === "unknown") {
-      console.warn(
-        `[host-agent] could not prove ownership of maintenance container ${name} ` +
-          `after a failed run; leaving it untouched (inspect exit ${inspected.code ?? "spawn"})`,
-      );
-    }
+    // applied (review 2026-08-18 round 3): only a positive label proof
+    // authorizes deleting it, and an unobservable one is never recycled for.
+    const settled = await settleAppleOneOff(
+      { cli, recycle: activation ? restart : askOwner },
+      oneOff,
+    );
+    // Unproven, or its client never reported its end (the container may yet
+    // be created): watched until it is settled.
+    const lateCreation = result.code === null;
+    if (appleOneOffNeedsWatch(settled, lateCreation)) void watchAppleOneOff(watched, oneOff, { lateCreation });
   }
   return result;
 }
@@ -533,7 +571,7 @@ const VOLUME_AGENT_CLIS: {
  * proof: another process can begin maintenance after a read-only check. The
  * locked reconcile below always performs its own proof before releasing.
  */
-async function probeVolumeAgentClis(): Promise<string[] | null> {
+async function probeVolumeAgentClis(activation: ActivationIsCurrent | null): Promise<string[] | null> {
   const checks = VOLUME_AGENT_CLIS.map((cli) => {
     const missing = `echo "UAI_MISSING:${cli.bin}"`;
     if (cli.expectedVersionOutput === undefined) {
@@ -565,7 +603,7 @@ async function probeVolumeAgentClis(): Promise<string[] | null> {
     "/bin/bash",
     "-c",
     checks,
-  ], SHORT_DOCKER_TIMEOUT_MS);
+  ], SHORT_DOCKER_TIMEOUT_MS, activation);
   if (check.code !== 0) {
     console.warn(
       `[host-agent] could not check agent CLIs in ${ASDF_DATA_VOLUME} (exit ` +
@@ -586,7 +624,7 @@ async function probeVolumeAgentClis(): Promise<string[] | null> {
  * root-created file; opening it read-only permits flock, then metadata repair
  * occurs while holding that same inode (never replace it under a waiter).
  */
-async function prepareAsdfMaintenanceLock(): Promise<boolean> {
+async function prepareAsdfMaintenanceLock(activation: ActivationIsCurrent | null): Promise<boolean> {
   const command =
     `set -eu; lock=${ASDF_MAINTENANCE_LOCK_PATH}; ` +
     `if [ -L "$lock" ]; then echo "unsafe symlink lock: $lock" >&2; exit 1; fi; ` +
@@ -608,7 +646,7 @@ async function prepareAsdfMaintenanceLock(): Promise<boolean> {
     "/bin/bash",
     "-c",
     command,
-  ], CLI_MAINTENANCE_TIMEOUT_MS);
+  ], CLI_MAINTENANCE_TIMEOUT_MS, activation);
   if (result.code === 0) return true;
   lastMaintenanceStderr = result.stderr;
   console.warn(
@@ -898,8 +936,8 @@ export function standardImageVolumeMaintenanceCommandForTest(
   );
 }
 
-async function reconcileVolumeAgentClis(): Promise<boolean> {
-  const missingBefore = await probeVolumeAgentClis();
+async function reconcileVolumeAgentClis(activation: ActivationIsCurrent | null): Promise<boolean> {
+  const missingBefore = await probeVolumeAgentClis(activation);
   if (missingBefore?.length) {
     console.log(
       `[host-agent] repairing ${ASDF_DATA_VOLUME}: agent CLI(s) ` +
@@ -937,7 +975,7 @@ async function reconcileVolumeAgentClis(): Promise<boolean> {
     "/bin/bash",
     "-c",
     command,
-  ], CLI_MAINTENANCE_TIMEOUT_MS);
+  ], CLI_MAINTENANCE_TIMEOUT_MS, activation);
   if (reconcile.code === 0) {
     console.log(
       `[host-agent] agent CLIs and Corepack current on ${ASDF_DATA_VOLUME}: ` +
@@ -1175,7 +1213,15 @@ function markAgentClisReady(): void {
  * surface the reason). Resolves `agentClisReady` on every exit path.
  */
 export function ensureStandardImage(
-  opts: { maxAgeMs?: number } = {},
+  opts: {
+    maxAgeMs?: number;
+    /** Only the runtime's activation passes this, answering whether it is
+     *  still the current activation: within it alone, and only while it is
+     *  current, may a wedged Apple runtime's services be restarted, since
+     *  its recovery follows its maintenance. Every other pass asks the
+     *  runtime's owner for that activation instead (#p2jdax). */
+    withinActivation?: ActivationIsCurrent;
+  } = {},
 ): Promise<StandardImageResult> {
   // ADR-133 sidecar mode: a task machine has no container image to keep —
   // its agent CLIs are baked into the machine image. Live 2026-09-10
@@ -1203,9 +1249,12 @@ export function ensureStandardImage(
   // Startup, runtime recovery, and a newly-arrived task can all discover the
   // same daemon transition. One shared volume repair/build must own that
   // window; concurrent maintenance containers can otherwise replace the same
-  // CLI shims underneath each other and defeat agentClisReady's fence.
-  return ensureQueue.run(key, () =>
-    ensureStandardImageInner(engines)
+  // CLI shims underneath each other and defeat agentClisReady's fence. The
+  // activation's pass never joins one begun outside it (which may not
+  // restart the runtime): it runs after it, as its own.
+  const activation = opts.withinActivation ?? null;
+  return ensureQueue.run(activation ? `activation:${key}` : key, () =>
+    ensureStandardImageInner(engines, activation)
       .then((result) => {
         if (result.ok) lastOkByKey.set(key, { at: Date.now(), result });
         else lastOkByKey.delete(key);
@@ -1222,6 +1271,10 @@ export function ensureStandardImage(
 /** Last successful pass per engine configuration (in-process). */
 const lastOkByKey = new Map<string, { at: number; result: StandardImageResult }>();
 
+/** The runtime's activation, asked whether it is still the current one: what
+ *  alone may restart a wedged Apple runtime's services (#p2jdax). */
+export type ActivationIsCurrent = () => boolean;
+
 /** Tests: forget every remembered pass. */
 export function resetStandardImageMemo(): void {
   lastOkByKey.clear();
@@ -1232,6 +1285,7 @@ export const MAINTENANCE_INTERVAL_MS = 60 * 60_000;
 
 async function ensureStandardImageInner(
   engines: OptionalEngineConfiguration,
+  activation: ActivationIsCurrent | null,
 ): Promise<StandardImageResult> {
   // 1. Shared asdf data volume — idempotent under Docker; the Apple CLI
   //    errors on an existing name, which is the same healthy outcome.
@@ -1459,7 +1513,7 @@ async function ensureStandardImageInner(
         "/usr/bin/test",
         "-d",
         "/uai-volume-probe/plugins",
-      ], CLI_MAINTENANCE_TIMEOUT_MS);
+      ], CLI_MAINTENANCE_TIMEOUT_MS, activation);
       // Only `/usr/bin/test`'s own exit 1 means "not seeded". Everything else
       // — a host-side deadline kill (null), an in-container SIGTERM/SIGKILL
       // (143/137: live 2026-08-17, a wedged apiserver let the probe run ten
@@ -1508,7 +1562,7 @@ async function ensureStandardImageInner(
           "/bin/sh",
           "-c",
           "cp -a /opt/asdf-data/. /uai-seed-target/ && chown -R node:node /uai-seed-target",
-        ], CLI_MAINTENANCE_TIMEOUT_MS);
+        ], CLI_MAINTENANCE_TIMEOUT_MS, activation);
         if (seed.code !== 0) {
           return {
             ok: false,
@@ -1535,7 +1589,7 @@ async function ensureStandardImageInner(
         // read-only CLI probe attaches fine next to tasks, and EXECUTING
         // every agent CLI is the same positive evidence the full reconcile
         // ends with — enough to defer on, and worth persisting as the proof.
-        const missing = await probeVolumeAgentClis();
+        const missing = await probeVolumeAgentClis(activation);
         if (missing !== null && missing.length === 0) {
           await writeVolumeReconcileProof();
           console.log(
@@ -1566,7 +1620,7 @@ async function ensureStandardImageInner(
         };
       }
     }
-    const lockPrepared = await prepareAsdfMaintenanceLock();
+    const lockPrepared = await prepareAsdfMaintenanceLock(activation);
     if (!lockPrepared) {
       if (await volumeBusyDeferral(engine, lastMaintenanceStderr)) {
         console.log(
@@ -1579,7 +1633,7 @@ async function ensureStandardImageInner(
         error: `Could not prepare shared runtime maintenance lock ${ASDF_MAINTENANCE_LOCK_PATH}.`,
       };
     }
-    if (!(await reconcileVolumeAgentClis())) {
+    if (!(await reconcileVolumeAgentClis(activation))) {
       if (await volumeBusyDeferral(engine, lastMaintenanceStderr)) {
         console.log(
           `[host-agent] shared runtime volume ${ASDF_DATA_VOLUME} is held by running task containers; deferring maintenance (prior reconcile proof present)`,

package/lib/stopped-task-status-queue.ts

@@ -17,22 +17,49 @@
  */
 export type StoppedTaskReason = "manual";
 
+interface StoppedTaskState {
+  status: string;
+  runEpoch: number;
+}
+
+interface PendingStoppedTaskStatus {
+  reason: StoppedTaskReason | undefined;
+  runEpoch: number | undefined;
+}
+
 export class StoppedTaskStatusQueue {
-  private readonly pending = new Map<string, StoppedTaskReason | undefined>();
+  private readonly pending = new Map<string, PendingStoppedTaskStatus>();
 
   constructor(
-    private readonly statusForTask: (
+    private readonly stateForTask: (
       taskId: string,
-    ) => string | null | undefined,
+    ) => StoppedTaskState | null | undefined,
   ) {}
 
-  enqueue(taskId: string, reason?: StoppedTaskReason): void {
+  enqueue(
+    taskId: string,
+    reason?: StoppedTaskReason,
+    runEpoch?: number,
+  ): void {
+    const previous = this.pending.get(taskId);
+    const previousEpoch = previous?.runEpoch ?? 0;
+    const nextEpoch = runEpoch ?? 0;
+    // A command result can arrive after the next assignment has already
+    // queued its own status. Run epochs are monotonic, so an older result must
+    // not replace the newer pending truth (or donate its reason to it).
+    if (previous !== undefined && nextEpoch < previousEpoch) return;
     // A reason, once known, STICKS across a re-enqueue. The same task can be
     // queued twice before a flush — an operator Stop, then a quarantine sweep
     // that finds its container already down — and the automatic pass arriving
     // second does not make the human's decision retroactively automatic.
     // Dropping it would silently hand the task back to every collaborator.
-    this.pending.set(taskId, reason ?? this.pending.get(taskId));
+    this.pending.set(taskId, {
+      reason:
+        previous !== undefined && previousEpoch === nextEpoch
+          ? reason ?? previous.reason
+          : reason,
+      runEpoch,
+    });
   }
 
   /** A failed taskUp may have stopped a legacy runtime before recreation lost
@@ -46,16 +73,47 @@ export class StoppedTaskStatusQueue {
     const task = (input as { task?: unknown }).task;
     if (!task || typeof task !== "object" || Array.isArray(task)) return false;
     const taskId = (task as { id?: unknown }).id;
-    if (typeof taskId !== "string" || this.statusForTask(taskId) !== "stopped") {
+    const state = typeof taskId === "string" ? this.stateForTask(taskId) : null;
+    if (typeof taskId !== "string" || state?.status !== "stopped") {
       return false;
     }
-    this.enqueue(taskId);
+    const hasRunEpoch = Object.hasOwn(task, "runEpoch");
+    const inputRunEpoch = (task as { runEpoch?: unknown }).runEpoch;
+    if (hasRunEpoch) {
+      if (
+        !Number.isSafeInteger(inputRunEpoch) ||
+        (inputRunEpoch as number) < 1 ||
+        inputRunEpoch !== state.runEpoch
+      ) {
+        return false;
+      }
+    } else if (state.runEpoch !== 0) {
+      // Never relabel a delayed v0 taskUp result as the current v1 run.
+      return false;
+    }
+    const runEpoch = hasRunEpoch ? (inputRunEpoch as number) : undefined;
+    this.enqueue(taskId, undefined, runEpoch);
     return true;
   }
 
-  flush(publish: (taskId: string, reason?: StoppedTaskReason) => void): void {
-    for (const [taskId, reason] of [...this.pending]) {
-      if (this.statusForTask(taskId) === "stopped") publish(taskId, reason);
+  flush(
+    publish: (
+      taskId: string,
+      reason?: StoppedTaskReason,
+      runEpoch?: number,
+    ) => void,
+  ): void {
+    for (const [taskId, pending] of [...this.pending]) {
+      const state = this.stateForTask(taskId);
+      if (
+        state?.status === "stopped" &&
+        (pending.runEpoch === undefined
+          ? state.runEpoch === 0
+          : state.runEpoch === pending.runEpoch)
+      ) {
+        if (pending.runEpoch === undefined) publish(taskId, pending.reason);
+        else publish(taskId, pending.reason, pending.runEpoch);
+      }
       this.pending.delete(taskId);
     }
   }