@ohos-ports/nx 23.3.0-beta.2 → 24.0.2-beta.0

package/dist/src/tasks-runner/task-orchestrator.js

@@ -22,6 +22,10 @@ const cache_1 = require("./cache");
 const forked_process_task_runner_1 = require("./forked-process-task-runner");
 const is_tui_enabled_1 = require("./is-tui-enabled");
 const pseudo_terminal_1 = require("./pseudo-terminal");
+const probes_1 = require("./readiness/probes");
+const ready_signal_1 = require("./readiness/ready-signal");
+const ready_signal_server_1 = require("./readiness/ready-signal-server");
+const ready_when_1 = require("./readiness/ready-when");
 const noop_child_process_1 = require("./running-tasks/noop-child-process");
 const output_prefix_1 = require("./running-tasks/output-prefix");
 const shared_running_task_1 = require("./running-tasks/shared-running-task");
@@ -36,6 +40,28 @@ const utils_1 = require("./utils");
 function resolveBatchTaskStatus(result) {
     return result.status ?? (result.success ? 'success' : 'failure');
 }
+function batchWorkerLogExplains(status) {
+    switch (status) {
+        case 'failure':
+        case 'stopped':
+        // The worker never reached it, e.g. `@nx/gradle` after a build failure
+        // outside the batch's own tasks
+        case 'skipped':
+            return true;
+        case 'success':
+        case 'local-cache':
+        case 'local-cache-kept-existing':
+        case 'remote-cache':
+            return false;
+        default: {
+            const unhandled = status;
+            void unhandled;
+            // Batch executors report their statuses untyped, so an unknown one can
+            // still arrive here. Nx can't tell it succeeded, so its log is shown
+            return true;
+        }
+    }
+}
 /** Whether a path names a file with bytes in it. */
 function hasContent(path) {
     try {
@@ -45,6 +71,31 @@ function hasContent(path) {
         return false;
     }
 }
+function createReadinessState(onSettled) {
+    const state = {
+        settled: false,
+        abort: new AbortController(),
+    };
+    state.promise = new Promise((resolve, reject) => {
+        state.resolve = () => {
+            if (state.settled)
+                return;
+            state.settled = true;
+            resolve();
+            onSettled('ready');
+        };
+        state.reject = (error) => {
+            if (state.settled)
+                return;
+            state.settled = true;
+            reject(error);
+            onSettled('failed');
+        };
+    });
+    // A producer with no waiter still settles; that must not be unhandled
+    state.promise.catch(() => { });
+    return state;
+}
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, 
@@ -53,7 +104,7 @@ class TaskOrchestrator {
     /** What this run renders with, after defaults. */
     resolvedOutputStyle, fullTaskGraph = taskGraph, 
     /** Tasks the up-front pass left to hash once the tasks they read from have run. */
-    deferredTaskIds) {
+    hashingDeferredTaskIds) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.initiatingTasks = initiatingTasks;
@@ -66,7 +117,7 @@ class TaskOrchestrator {
         this.specifiedOutputStyle = specifiedOutputStyle;
         this.resolvedOutputStyle = resolvedOutputStyle;
         this.fullTaskGraph = fullTaskGraph;
-        this.deferredTaskIds = deferredTaskIds;
+        this.hashingDeferredTaskIds = hashingDeferredTaskIds;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
         this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
@@ -78,13 +129,17 @@ class TaskOrchestrator {
             ? new native_1.RunningTasksService((0, db_connection_1.getLocalDbConnection)())
             : null;
         this.taskInvocationTracker = !native_1.IS_WASM
-            ? new native_1.TaskInvocationTracker((0, db_connection_1.getLocalDbConnection)(), Number(process.env.NX_INVOCATION_ROOT_PID ?? process.pid))
+            ? new native_1.TaskInvocationTracker((0, db_connection_1.getLocalDbConnection)(), (0, task_env_1.getInvocationRootPid)(), (0, task_env_1.getInvocationAncestorPids)())
             : null;
-        // Tracks tasks registered by THIS process so that recursive code paths
-        // (e.g. applyFromCacheOrRunBatch looping on incomplete batches) don't
-        // re-register and trip the DB uniqueness constraint.
+        // Task ids this process has already registered. Recursive code paths (e.g.
+        // applyFromCacheOrRunBatch looping on incomplete batches) re-enter the
+        // detector for the same task; skipping them saves a DB round trip. A task id
+        // is unique within one process, so it is enough to identify the row.
         this.registeredInvocations = new Set();
-        this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.projects, this.taskGraph, this.options);
+        this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.projects, this.taskGraph, this.options, this.fullTaskGraph, {
+            readinessElsewhere: (producerId) => this.runningTasksService?.getTaskReadiness(producerId) ?? null,
+            onReadinessHold: (producerId) => this.onReadinessHold(producerId),
+        });
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
@@ -123,6 +178,16 @@ class TaskOrchestrator {
         this.runningDiscreteTasks = new Map();
         this.discreteTaskExitHandled = new Map();
         this.continuousTaskExitHandled = new Map();
+        // Keyed by producer id: a producer this process started or shares
+        this.readiness = new Map();
+        // Producers that failed their check while still running: the exit must not
+        // report them again, and the saved log gets the reason after the transcript
+        this.readinessFailures = new Map();
+        this.readinessFailureReasons = new Map();
+        this.readinessSettled = false;
+        // The url each producer reported with its readiness signal
+        this.readyUrls = new Map();
+        this.waitingLogged = new Set();
         this.cleanupPromise = null;
         this.signalHandlers = [];
         // Tasks whose runner already owns the write to
@@ -210,8 +275,22 @@ class TaskOrchestrator {
      */
     async executeCoordinatorLoop(doNotSkipCache, parallelism) {
         while (true) {
-            if (this.bailed || this.stopRequested)
+            if (this.stopRequested)
+                break;
+            // On bail, start nothing new but let running tasks finish. Skip unstarted
+            // discrete tasks unless stopped, so the run still reads as interrupted
+            if (this.bailed) {
+                await Promise.allSettled(this.pendingDiscreteWorkers);
+                if (this.stopRequested)
+                    break;
+                for (const task of Object.values(this.taskGraph.tasks)) {
+                    if (!task.continuous && !this.completedTasks.has(task.id)) {
+                        this.completedTasks.set(task.id, 'skipped');
+                    }
+                }
                 break;
+            }
+            await this.scheduleAfterReadiness();
             // 1. Hash BEFORE processAll so processTask sees hashes set, and so
             //    resolveCachedTasksBulk can look them up in the cache. Each task
             //    is hashed with its own task-specific env (project/target .env
@@ -223,7 +302,7 @@ class TaskOrchestrator {
                 const unhashed = scheduledTasks
                     .map((id) => this.taskGraph.tasks[id])
                     .filter((t) => !t.hash &&
-                    this.taskGraph.dependencies[t.id].every((depId) => this.completedTasks.has(depId)));
+                    this.taskGraph.dependencies[t.id].every(({ id }) => this.completedTasks.has(id)));
                 if (unhashed.length > 0) {
                     const perTaskEnvs = {};
                     for (const task of unhashed) {
@@ -238,6 +317,11 @@ class TaskOrchestrator {
                 const resolved = await this.resolveCachedTasksBulk();
                 if (resolved)
                     continue;
+                // A pass from a continuous loop during the waits above may have
+                // admitted tasks this iteration never looked up; they must not reach
+                // step 5 without a confirmed miss
+                if (this.hasUnresolvedCacheableTask())
+                    continue;
             }
             // 3. Process remaining scheduled tasks (cache misses + non-cacheable).
             this.processAllScheduledTasks();
@@ -249,6 +333,9 @@ class TaskOrchestrator {
                 this.openGroup(groupId);
                 continue;
             }
+            // A task may have failed during one of the awaits above
+            if (this.bailed)
+                continue;
             // 5. Dispatch cache misses as individual workers
             while (this.pendingDiscreteWorkers.size < parallelism) {
                 const task = this.tasksSchedule.nextTask((t) => !t.continuous);
@@ -263,6 +350,10 @@ class TaskOrchestrator {
                 break;
             }
             // 7. Wait for a worker to finish (woken by scheduleNextTasksAndReleaseThreads)
+            // A verdict that landed during this iteration found nothing parked,
+            // so run its pass instead of parking
+            if (this.readinessSettled)
+                continue;
             await new Promise((res) => this.waitingForTasks.push(res));
         }
     }
@@ -272,6 +363,7 @@ class TaskOrchestrator {
             if (!this.tasksSchedule.hasTasks() || this.bailed || this.stopRequested) {
                 return null;
             }
+            await this.scheduleAfterReadiness();
             this.processAllScheduledTasks();
             const task = this.tasksSchedule.nextTask((t) => t.continuous);
             if (task) {
@@ -293,9 +385,29 @@ class TaskOrchestrator {
                 return null;
             }
             // block until some other task completes, then try again
+            if (this.readinessSettled)
+                continue;
             await new Promise((res) => this.waitingForTasks.push(res));
         }
     }
+    hasUnresolvedCacheableTask() {
+        return this.tasksSchedule
+            .getAllScheduledTasks()
+            .scheduledTasks.some((id) => {
+            const task = this.taskGraph.tasks[id];
+            return (!task.continuous &&
+                task.cache &&
+                (!task.hash || !this.cacheMissedHashes.has(task.hash)));
+        });
+    }
+    // A verdict releases tasks the schedule has not admitted yet. Whichever
+    // loop wakes first runs the pass; the coordinator may be inside a batch.
+    async scheduleAfterReadiness() {
+        if (this.readinessSettled) {
+            this.readinessSettled = false;
+            await this.scheduleNextTasksAndReleaseThreads();
+        }
+    }
     // region Processing Scheduled Tasks
     async processTask(taskId) {
         const task = this.taskGraph.tasks[taskId];
@@ -308,7 +420,10 @@ class TaskOrchestrator {
     }
     processAllScheduledTasks() {
         const { scheduledTasks } = this.tasksSchedule.getAllScheduledTasks();
-        for (const taskId of scheduledTasks) {
+        this.processTasks(scheduledTasks);
+    }
+    processTasks(taskIds) {
+        for (const taskId of taskIds) {
             // Task is already handled or being handled
             if (!this.processedTasks.has(taskId)) {
                 this.processedTasks.set(taskId, this.processTask(taskId));
@@ -316,39 +431,59 @@ class TaskOrchestrator {
         }
     }
     /**
-     * Registers a task invocation and checks for loops across nested Nx processes.
-     * Uses the task_invocations DB table keyed by root PID. registerTask() throws
-     * on unique constraint violation when a parent Nx process already registered
-     * this task — indicating an infinite loop.
+     * Registers a task invocation and checks for loops across nested Nx
+     * processes. registerTask() returns the invocation chain only when an
+     * *ancestor* Nx process is already running this task — a genuine loop.
+     * Sibling processes running the same task are legitimate and register
+     * without complaint.
+     *
+     * The overrides hash rides along with the task id so the tracker can tell an
+     * ancestor re-invoking a task with different arguments from one repeating
+     * the same invocation.
      */
     detectTaskInvocationLoop(task) {
         if (!this.taskInvocationTracker)
             return;
         if (this.registeredInvocations.has(task.id))
             return;
+        let chain;
         try {
-            this.taskInvocationTracker.registerTask(process.pid, task.id);
+            chain = this.taskInvocationTracker.registerTask(process.pid, task.id, (0, utils_1.hashTaskOverrides)(task));
+        }
+        catch {
+            // Loop detection is diagnostic only; a DB failure must not fail the run
+            // or be mistaken for a loop.
+            return;
+        }
+        if (!chain) {
             this.registeredInvocations.add(task.id);
+            return;
+        }
+        const chainDisplay = chain.map((r) => r.taskId).join(' -> ');
+        output_1.output.error({
+            title: 'Recursive task invocation detected',
+            bodyLines: [
+                `Nx detected a recursive loop of task invocations:`,
+                ``,
+                `  ${chainDisplay} -> ${task.id}`,
+                ``,
+                `Task "${task.id}" was already invoked by a parent Nx process in this chain.`,
+                `This typically happens when a task's command (e.g., "nx ${task.target.target} ${task.target.project}")`,
+                `triggers a chain of tasks that eventually re-invokes itself.`,
+                ``,
+                `To fix this, review the command configuration for the tasks in the chain above.`,
+            ],
+        });
+        process.exit(1);
+    }
+    releaseTaskInvocation(task) {
+        if (!this.registeredInvocations.delete(task.id))
+            return;
+        try {
+            this.taskInvocationTracker?.unregisterTask(process.pid, task.id);
         }
         catch {
-            // Unique constraint violation — task already invoked by an ancestor Nx process
-            const chain = this.taskInvocationTracker.getInvocationChain();
-            const chainDisplay = chain.map((r) => r.taskId).join(' -> ');
-            output_1.output.error({
-                title: 'Recursive task invocation detected',
-                bodyLines: [
-                    `Nx detected a recursive loop of task invocations:`,
-                    ``,
-                    `  ${chainDisplay} -> ${task.id}`,
-                    ``,
-                    `Task "${task.id}" was already invoked by a parent Nx process in this chain.`,
-                    `This typically happens when a task's command (e.g., "nx ${task.target.target} ${task.target.project}")`,
-                    `triggers a chain of tasks that eventually re-invokes itself.`,
-                    ``,
-                    `To fix this, review the command configuration for the tasks in the chain above.`,
-                ],
-            });
-            process.exit(1);
+            // Diagnostic only, like registration. A leftover row is swept as stale.
         }
     }
     // endregion Processing Scheduled Tasks
@@ -483,38 +618,63 @@ class TaskOrchestrator {
     /**
      * Hash all batch tasks and resolve cache hits topologically.
      *
-     * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
-     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
-     * receive a preliminary hash — they'll be re-hashed after execution.
+     * Walks the task graph level by level. A deferred task (its hash reads
+     * another task's outputs) behind an upstream batch task that still has to
+     * run is never looked up yet:
+     * - behind a non-cacheable task only, it is held back for a later wave,
+     *   where it hashes after that task ran;
+     * - behind a cache miss, it runs in this wave and re-hashes after execution.
+     * Every task run in this wave gets a hash first, for Cloud's startTasks.
      */
     async applyBatchCachedResults(batch, doNotSkipCache, groupId) {
         const cachedResults = [];
-        const needsRehashAfterExecution = new Set();
+        const rehashAfterRun = new Set();
         const tasks = Object.values(batch.taskGraph.tasks);
         if (!doNotSkipCache) {
             // Cache skipped — just hash so startTasks has valid hashes
             await this.hashBatchTasks(tasks);
-            return { cachedResults, needsRehashAfterExecution };
-        }
-        const nonCachedTaskIds = new Set();
-        await (0, task_graph_utils_1.walkTaskGraph)(batch.taskGraph, async (rootTaskIds) => {
-            const rootTasks = rootTaskIds.map((id) => batch.taskGraph.tasks[id]);
-            await this.hashBatchTasks(rootTasks);
-            const eligible = [];
-            for (const task of rootTasks) {
-                const depIds = batch.taskGraph.dependencies[task.id];
-                const hasNonCachedDep = depIds.some((id) => nonCachedTaskIds.has(id));
-                if (hasNonCachedDep && this.deferredTaskIds?.has(task.id)) {
-                    nonCachedTaskIds.add(task.id);
-                    needsRehashAfterExecution.add(task.id);
+            return { cachedResults, tasksToRun: tasks, rehashAfterRun };
+        }
+        const toRun = new Map();
+        // Neither restored nor run in this wave; a later wave picks them up.
+        const heldBack = new Set();
+        // Tasks with a cache miss / a non-cacheable task upstream that still has
+        // to run in this wave.
+        const behindMiss = new Set();
+        const behindUncacheable = new Set();
+        const pending = (id, cacheable) => toRun.has(id) && !!toRun.get(id).cache === cacheable;
+        await (0, task_graph_utils_1.walkTaskGraph)(batch.taskGraph, async (levelIds) => {
+            const runNow = [];
+            const lookUp = [];
+            for (const id of levelIds) {
+                const task = batch.taskGraph.tasks[id];
+                const deps = batch.taskGraph.dependencies[id].map((dep) => dep.id);
+                if (deps.some((dep) => heldBack.has(dep))) {
+                    heldBack.add(id);
+                    continue;
+                }
+                const afterMiss = deps.some((dep) => behindMiss.has(dep) || pending(dep, true));
+                const afterUncacheable = deps.some((dep) => behindUncacheable.has(dep) || pending(dep, false));
+                if (afterMiss)
+                    behindMiss.add(id);
+                if (afterUncacheable)
+                    behindUncacheable.add(id);
+                const deferred = this.hashingDeferredTaskIds?.has(id);
+                if (deferred && afterMiss) {
+                    runNow.push(task);
+                    toRun.set(id, task);
+                    rehashAfterRun.add(id);
+                }
+                else if (deferred && afterUncacheable) {
+                    heldBack.add(id);
                 }
                 else {
-                    eligible.push(task);
+                    lookUp.push(task);
                 }
             }
-            if (eligible.length > 0) {
-                const cacheResults = await this.applyCachedResults(eligible);
+            await this.hashBatchTasks([...runNow, ...lookUp]);
+            if (lookUp.length > 0) {
+                const cacheResults = await this.applyCachedResults(lookUp);
                 const cachedIds = new Set(cacheResults.map((r) => r.task.id));
                 cachedResults.push(...cacheResults);
                 if (cacheResults.length > 0) {
@@ -524,14 +684,14 @@ class TaskOrchestrator {
                     // Replayed from the cache — don't write the results back.
                     await this.postRunSteps(cacheResults, false, groupId);
                 }
-                for (const task of eligible) {
+                for (const task of lookUp) {
                     if (!cachedIds.has(task.id)) {
-                        nonCachedTaskIds.add(task.id);
+                        toRun.set(task.id, task);
                     }
                 }
             }
         });
-        return { cachedResults, needsRehashAfterExecution };
+        return { cachedResults, tasksToRun: [...toRun.values()], rehashAfterRun };
     }
     async hashBatchTasks(tasks) {
         // Batch executors run every task in the same forked process, but
@@ -545,27 +705,52 @@ class TaskOrchestrator {
         await (0, hash_task_1.hashTasks)(this.hasher, this.projectGraph, this.fullTaskGraph, perTaskEnvs, this.taskDetails, tasks);
     }
     async applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId) {
+        if (this.bailed || this.stopRequested) {
+            return [];
+        }
         const applyFromCacheOrRunBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:start');
-        const taskEntries = Object.entries(batch.taskGraph.tasks);
-        const tasks = taskEntries.map(([, task]) => task);
+        const taskIds = Object.keys(batch.taskGraph.tasks);
         this.options.lifeCycle.registerRunningBatch?.(batch.id, {
             executorName: batch.executorName,
-            taskIds: Object.keys(batch.taskGraph.tasks),
+            taskIds,
         });
-        const { cachedResults, needsRehashAfterExecution } = await this.applyBatchCachedResults(batch, doNotSkipCache, groupId);
-        // Schedule and start non-cached tasks (cached tasks were already
-        // started and completed inside applyBatchCachedResults)
-        const cachedTaskIds = new Set(cachedResults.map((r) => r.task.id));
-        const nonCachedTasks = tasks.filter((t) => !cachedTaskIds.has(t.id));
-        if (nonCachedTasks.length > 0) {
-            await Promise.all(nonCachedTasks.map((task) => this.options.lifeCycle.scheduleTask(task)));
-            await this.preRunSteps(nonCachedTasks, { groupId });
-        }
-        // Phase 2: Run non-cached tasks, then re-hash tasks that read their outputs
-        const taskIdsToSkip = cachedResults.map((r) => r.task.id);
+        // Each wave restores or runs what it can; tasks held back for a later
+        // wave (or left out by the executor) stay incomplete and go again.
+        const results = [];
+        let taskGraph = batch.taskGraph;
+        while (Object.keys(taskGraph.tasks).length > 0 &&
+            !this.bailed &&
+            !this.stopRequested) {
+            results.push(...(await this.runBatchWave(doNotSkipCache, { ...batch, taskGraph }, groupId)));
+            this.forkedProcessTaskRunner.cleanUpBatchProcesses();
+            taskGraph = (0, utils_1.removeTasksFromTaskGraph)(taskGraph, Object.keys(taskGraph.tasks).filter((id) => this.completedTasks.has(id)));
+        }
+        // Once, after every wave: an earlier status would end the batch in the TUI.
+        const hasFailures = taskIds.some((taskId) => {
+            const status = this.completedTasks.get(taskId);
+            return status === 'failure' || status === 'skipped';
+        });
+        this.options.lifeCycle.setBatchStatus?.(batch.id, hasFailures ? "Failure" /* BatchStatus.Failure */ : "Success" /* BatchStatus.Success */);
+        const applyFromCacheOrRunBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:end');
+        perf_hooks_1.performance.measure('TaskOrchestrator-apply-from-cache-or-run-batch', applyFromCacheOrRunBatchStart.name, applyFromCacheOrRunBatchEnd.name);
+        return results;
+    }
+    async runBatchWave(doNotSkipCache, batch, groupId) {
+        const tasks = Object.values(batch.taskGraph.tasks);
+        const { cachedResults, tasksToRun: wave, rehashAfterRun, } = await this.applyBatchCachedResults(batch, doNotSkipCache, groupId);
+        // Cached tasks were started and completed inside applyBatchCachedResults;
+        // a member skipped meanwhile (a dependency failed) must not run either
+        const tasksToRun = wave.filter((t) => !this.completedTasks.has(t.id));
+        if (tasksToRun.length > 0) {
+            await Promise.all(tasksToRun.map((task) => this.options.lifeCycle.scheduleTask(task)));
+            await this.preRunSteps(tasksToRun, { groupId });
+        }
+        // Phase 2: Run this wave's tasks, then re-hash those run without a lookup
         let batchResults = [];
-        if (taskIdsToSkip.length < tasks.length) {
-            const runGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, taskIdsToSkip);
+        // Read again: a member can be skipped while the hooks above ran
+        const runIds = new Set(tasksToRun.filter((t) => !this.completedTasks.has(t.id)).map((t) => t.id));
+        if (runIds.size > 0) {
+            const runGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, tasks.filter((t) => !runIds.has(t.id)).map((t) => t.id));
             for (const task of Object.values(runGraph.tasks)) {
                 this.detectTaskInvocationLoop(task);
             }
@@ -576,7 +761,7 @@ class TaskOrchestrator {
             }, this.batchEnv, groupId);
             // Re-hash tasks that read dep outputs — those outputs are now on disk
             const tasksToRehash = batchResults
-                .filter((r) => needsRehashAfterExecution.has(r.task.id) &&
+                .filter((r) => rehashAfterRun.has(r.task.id) &&
                 (r.status === 'success' || r.status === 'failure'))
                 .map((r) => r.task);
             if (tasksToRehash.length > 0) {
@@ -592,25 +777,6 @@ class TaskOrchestrator {
         if (batchResults.length > 0) {
             await this.postRunSteps(batchResults, doNotSkipCache, groupId);
         }
-        // Update batch status based on all task results
-        const hasFailures = taskEntries.some(([taskId]) => {
-            const status = this.completedTasks.get(taskId);
-            return status === 'failure' || status === 'skipped';
-        });
-        this.options.lifeCycle.setBatchStatus?.(batch.id, hasFailures ? "Failure" /* BatchStatus.Failure */ : "Success" /* BatchStatus.Success */);
-        this.forkedProcessTaskRunner.cleanUpBatchProcesses();
-        const tasksCompleted = taskEntries.filter(([taskId]) => this.completedTasks.has(taskId));
-        // Batch is still not done, run it again
-        if (tasksCompleted.length !== taskEntries.length) {
-            await this.applyFromCacheOrRunBatch(doNotSkipCache, {
-                id: batch.id,
-                executorName: batch.executorName,
-                taskGraph: (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, tasksCompleted.map(([taskId]) => taskId)),
-            }, groupId);
-        }
-        // Batch is done, mark it as completed
-        const applyFromCacheOrRunBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:end');
-        perf_hooks_1.performance.measure('TaskOrchestrator-apply-from-cache-or-run-batch', applyFromCacheOrRunBatchStart.name, applyFromCacheOrRunBatchEnd.name);
         return [...cachedResults, ...batchResults];
     }
     async runBatch(batch, env, groupId) {
@@ -639,7 +805,8 @@ class TaskOrchestrator {
                 // When the batch is being folded, printing is deferred to batch end
                 // (printGroupedBatchOutput), which always renders each task through the
                 // life cycle and adds the worker's whole log as a fold when the run
-                // asked for full output or any task failed or was stopped.
+                // asked for full output or any task failed, was stopped or was never
+                // reached.
                 if (status !== 'skipped' && !(0, output_1.shouldGroupBatchOutput)()) {
                     this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
                 }
@@ -734,7 +901,7 @@ class TaskOrchestrator {
         if (!capturedOutputPath || (0, output_1.printsTaskOutput)(this.resolvedOutputStyle)) {
             return;
         }
-        const failed = results.some((r) => r.status === 'failure' || r.status === 'stopped');
+        const failed = results.some((r) => batchWorkerLogExplains(r.status));
         if (!failed) {
             return;
         }
@@ -784,8 +951,9 @@ class TaskOrchestrator {
      * those per-project summaries to the worker's stdio at all.
      *
      * The worker's whole captured log is rendered as a fold above them when the
-     * run asked for full output, or when any task failed or was stopped. A
-     * diagnostic that explains a failure is routinely one no task claimed:
+     * run asked for full output, or when any task failed, was stopped or was
+     * never reached.
+     * A diagnostic that explains a failure is routinely one no task claimed:
      * `@nx/maven`'s batch impl writes its exit-code dump and failed-task outputs
      * to the worker's stderr via `console.error`, and the Maven JVM it spawns
      * points slf4j at `System.out` because its own stderr carries the result
@@ -821,7 +989,7 @@ class TaskOrchestrator {
             verbose: this.options.verbose,
             outputStyle: this.resolvedOutputStyle,
         });
-        const batchOwnsTheDiagnostic = taskResults.some((r) => r.status === 'failure' || r.status === 'stopped');
+        const batchOwnsTheDiagnostic = taskResults.some((r) => batchWorkerLogExplains(r.status));
         if ((0, output_1.printsTaskOutput)(this.resolvedOutputStyle) &&
             (printsFullOutput || batchOwnsTheDiagnostic) &&
             capturedOutputPath) {
@@ -855,7 +1023,9 @@ class TaskOrchestrator {
             ? 'failure'
             : taskResults.some((r) => r.status === 'stopped')
                 ? 'stopped'
-                : 'success';
+                : taskResults.some((r) => r.status === 'skipped')
+                    ? 'skipped'
+                    : 'success';
         output_1.output.logBatchGroup(label, body, worst);
         if (!redirectLines) {
             return;
@@ -876,8 +1046,8 @@ class TaskOrchestrator {
      * for running those via {@link runTaskDirectly}.
      *
      * Fires scheduleTask lifecycle for hits that haven't been through
-     * processAllScheduledTasks yet. That's a coordinator gap-filler and
-     * a no-op for callers that pre-process the schedule.
+     * processTasks yet. That's a coordinator gap-filler and a no-op for
+     * callers that process their tasks first.
      *
      * The caller provides `groupId` — cache hits share one slot since they
      * don't actually compete for parallelism.
@@ -896,7 +1066,7 @@ class TaskOrchestrator {
             return [];
         // scheduleTask lifecycle for hits the coordinator resolved before
         // processAllScheduledTasks could fire it. No-op for callers that
-        // already ran processAllScheduledTasks (every hit is in processedTasks).
+        // already ran processTasks (every hit is in processedTasks).
         await Promise.all(cacheHits
             .filter(({ task }) => !this.processedTasks.has(task.id))
             .map(({ task }) => this.options.lifeCycle.scheduleTask(task)));
@@ -923,8 +1093,7 @@ class TaskOrchestrator {
             // Wake coordinator — the delete above may satisfy the exit condition
             // (pendingDiscreteWorkers.size === 0) that was missed when
             // scheduleNextTasksAndReleaseThreads fired earlier.
-            this.waitingForTasks.forEach((f) => f(null));
-            this.waitingForTasks.length = 0;
+            this.releaseThreads();
         });
         this.pendingDiscreteWorkers.add(worker);
     }
@@ -947,13 +1116,36 @@ class TaskOrchestrator {
         await this.postRunSteps([{ task, status: 'failure', terminalOutput }], doNotSkipCache, groupId);
     }
     /**
-     * Spawn and wait on a task's child process, unconditionally — no cache
-     * lookup. Callers must have already confirmed the task is a cache miss
-     * (or disabled caching entirely).
+     * Spawn and wait on a task's child process once its ready dependencies are
+     * ready, with no cache lookup. Callers must have already confirmed the task
+     * is a cache miss (or disabled caching entirely).
      */
     async runTaskDirectly(doNotSkipCache, task, groupId) {
         // Wait for task to be processed
         const taskSpecificEnv = await this.processedTasks.get(task.id);
+        const waitError = await this.waitForReadyDependencies(task).then(() => null, (e) => e);
+        // Skipped by a failed dependency's propagation while waiting
+        if (this.completedTasks.has(task.id)) {
+            return {
+                task,
+                code: 1,
+                status: this.completedTasks.get(task.id),
+                terminalOutput: '',
+            };
+        }
+        if (waitError instanceof ready_when_1.ProducerFailedError) {
+            await this.skipWaiter(task, groupId);
+            return { task, code: 1, status: 'skipped', terminalOutput: '' };
+        }
+        if (waitError) {
+            await this.failTaskBeforeStart(task, groupId, waitError, doNotSkipCache);
+            return {
+                task,
+                code: 1,
+                status: 'failure',
+                terminalOutput: waitError.message,
+            };
+        }
         await this.preRunSteps([task], { groupId });
         const pipeOutput = await this.pipeOutputCapture(task);
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
@@ -968,6 +1160,7 @@ class TaskOrchestrator {
         const env = pipeOutput
             ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, (0, task_env_1.getForceColorForChild)(), this.options.skipNxCache, this.options.captureStderr, null, null)
             : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
+        Object.assign(env, this.getReadyUrlEnv(task));
         let resolveDiscreteExit;
         const discreteExitHandled = new Promise((r) => (resolveDiscreteExit = r));
         this.discreteTaskExitHandled.set(task.id, discreteExitHandled);
@@ -1005,27 +1198,21 @@ class TaskOrchestrator {
             try {
                 const { schema } = (0, utils_1.getExecutorForTask)(task, this.projects);
                 const combinedOptions = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? targetConfiguration.defaultConfiguration, targetConfiguration, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspace_root_1.workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
-                if (combinedOptions.env) {
-                    env = {
-                        ...env,
-                        ...combinedOptions.env,
-                    };
-                }
                 if (streamOutput) {
                     const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
                     output_1.output.logCommand(args.join(' '));
                 }
                 const runCommandsOptions = {
                     ...combinedOptions,
-                    env,
                     usePty: this.tuiEnabled ||
                         (!this.tasksSchedule.hasTasks() &&
                             this.runningContinuousTasks.size === 0),
                     streamOutput: streamOutput && !shouldPrefix,
                 };
+                // As in a forked run, run-commands builds its env on the task env
                 const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
-                }, task);
+                }, task, env);
                 this.runningRunCommandsTasks.set(task.id, runningTask);
                 runningTask.onExit(() => {
                     this.runningRunCommandsTasks.delete(task.id);
@@ -1165,11 +1352,37 @@ class TaskOrchestrator {
     async startContinuousTask(task, groupId) {
         if (this.runningTasksService &&
             this.runningTasksService.getRunningTasks([task.id]).length) {
+            // This branch never reads the hash, so a failure to compute it is dropped
+            void this.processedTasks.get(task.id)?.catch(() => { });
+            let readyWhen;
+            let uncheckedReason;
+            try {
+                ({ readyWhen, uncheckedReason } = this.getReadinessCheck(task, () => this.getReadyWhenWait(task)));
+            }
+            catch (e) {
+                return this.failTaskBeforeStart(task, groupId, e);
+            }
             await this.preRunSteps([task], { groupId });
             if (this.tuiEnabled) {
                 this.options.lifeCycle.setTaskStatus(task.id, 8 /* NativeTaskStatus.Shared */);
             }
             const runningTask = new shared_running_task_1.SharedRunningTask(this.runningTasksService, task.id);
+            if (uncheckedReason) {
+                this.warnUncheckedReadiness(task, uncheckedReason);
+            }
+            if (readyWhen) {
+                const state = this.armReadiness(task.id);
+                this.pollReadinessRow(task, readyWhen, {
+                    signal: state.abort.signal,
+                    ownerObserved: true,
+                }).then(() => {
+                    if (!state.abort.signal.aborted)
+                        state.resolve();
+                }, (e) => {
+                    if (!state.abort.signal.aborted)
+                        this.failReadiness(task, state, e);
+                });
+            }
             this.runningContinuousTasks.set(task.id, {
                 runningTask,
                 groupId,
@@ -1183,34 +1396,95 @@ class TaskOrchestrator {
             }));
             // task is already running by another process, we schedule the next tasks
             // and release the threads
+            this.tasksSchedule.markContinuousTaskStarted(task.id);
             await this.scheduleNextTasksAndReleaseThreads();
             return runningTask;
         }
-        const taskSpecificEnv = await this.processedTasks.get(task.id);
-        await this.preRunSteps([task], { groupId });
-        const pipeOutput = await this.pipeOutputCapture(task);
-        // obtain metadata
-        const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        // Deliberately not gated on `printsTaskOutput`, unlike `runTaskDirectly`.
-        // `SummaryTerminalOutputLifeCycle.printTaskTerminalOutput` is a no-op and it
-        // only reports at `endCommand`, which never runs for a task that does not
-        // end - so suppressing here would leave a `nx serve` under `summary` with a
-        // permanently silent terminal and no file to read yet. Streaming is the only
-        // channel a continuous task has.
-        const streamOutput = (0, output_1.isStaticOutputStyle)(this.specifiedOutputStyle)
-            ? false
-            : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
-        let env = pipeOutput
-            ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, (0, task_env_1.getForceColorForChild)(), this.options.skipNxCache, this.options.captureStderr, null, null)
-            : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
-        this.detectTaskInvocationLoop(task);
-        const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
+        // Claim the task before doing any of the work below. getRunningTasks()
+        // above is a check-then-act: until this row exists, a sibling Nx process
+        // asking the same question is told the task is not running and starts a
+        // duplicate of it.
         this.runningTasksService?.addRunningTask(task.id);
-        this.runningContinuousTasks.set(task.id, {
-            runningTask: childProcess,
-            groupId,
-            ownsRunningTasksService: true,
-        });
+        let pipeOutput;
+        let temporaryOutputPath;
+        let streamOutput;
+        let env;
+        let readyWhen;
+        let uncheckedReason;
+        let readyOnStart;
+        try {
+            const taskSpecificEnv = await this.processedTasks.get(task.id);
+            pipeOutput = await this.pipeOutputCapture(task);
+            // obtain metadata
+            temporaryOutputPath = this.cache.temporaryOutputPath(task);
+            // Deliberately not gated on `printsTaskOutput`, unlike `runTaskDirectly`.
+            // `SummaryTerminalOutputLifeCycle.printTaskTerminalOutput` is a no-op and it
+            // only reports at `endCommand`, which never runs for a task that does not
+            // end - so suppressing here would leave a `nx serve` under `summary` with a
+            // permanently silent terminal and no file to read yet. Streaming is the only
+            // channel a continuous task has.
+            streamOutput = (0, output_1.isStaticOutputStyle)(this.specifiedOutputStyle)
+                ? false
+                : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
+            env = pipeOutput
+                ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, (0, task_env_1.getForceColorForChild)(), this.options.skipNxCache, this.options.captureStderr, null, null)
+                : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
+            const readyWhenInputs = (0, ready_when_1.getReadyWhenInputs)(task, this.projectGraph, this.projects, workspace_root_1.workspaceRoot);
+            this.checkReadyWhenBeforeWait(task, env, readyWhenInputs);
+            await this.waitForReadyDependencies(task);
+            Object.assign(env, this.getReadyUrlEnv(task));
+            ({ readyWhen, uncheckedReason, readyOnStart } = this.getReadinessCheck(task, () => this.getReadyWhen(task, env, readyWhenInputs)));
+            if (readyWhen?.kind === 'signal') {
+                this.readySignal ??= new ready_signal_server_1.ReadySignalServer();
+                Object.assign(env, await this.readySignal.env(task.id));
+            }
+        }
+        catch (e) {
+            this.runningTasksService?.removeRunningTask(task.id);
+            if (e instanceof ready_when_1.ProducerFailedError) {
+                await this.skipWaiter(task, groupId);
+                return new noop_child_process_1.NoopChildProcess({ code: 1, terminalOutput: '' });
+            }
+            return this.failTaskBeforeStart(task, groupId, e);
+        }
+        // Skipped by a failed dependency's propagation while waiting
+        if (this.completedTasks.has(task.id)) {
+            this.runningTasksService?.removeRunningTask(task.id);
+            return new noop_child_process_1.NoopChildProcess({ code: 1, terminalOutput: '' });
+        }
+        let childProcess;
+        try {
+            await this.preRunSteps([task], { groupId });
+            this.detectTaskInvocationLoop(task);
+            childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
+            this.tasksSchedule.markContinuousTaskStarted(task.id);
+            if (uncheckedReason) {
+                this.warnUncheckedReadiness(task, uncheckedReason);
+                // No probe settles the row, and a waiter in another process polls it
+                this.publishReadiness(task, 2 /* TaskReadiness.Failed */);
+            }
+            if (readyWhen) {
+                this.startReadinessProbe(task, readyWhen, childProcess);
+            }
+            // Waiters here, in other processes and in the TUI hold on a configured
+            // readyWhen until it gets a verdict
+            if (readyOnStart) {
+                this.recordReadiness(task, 1 /* TaskReadiness.Ready */);
+                this.armReadiness(task.id).resolve();
+            }
+            this.runningContinuousTasks.set(task.id, {
+                runningTask: childProcess,
+                groupId,
+                ownsRunningTasksService: true,
+            });
+        }
+        catch (e) {
+            // Nothing owns the claim until runningContinuousTasks holds it — the
+            // release paths (completeContinuousTask, the signal handler) both iterate
+            // that map. Drop it here or siblings wait on a task no one is running.
+            this.runningTasksService?.removeRunningTask(task.id);
+            throw e;
+        }
         this.continuousTaskExitHandled.set(task.id, new Promise((resolve) => {
             childProcess.onExit(async (code) => {
                 await this.handleContinuousTaskExit(code, task, groupId, true);
@@ -1224,6 +1498,299 @@ class TaskOrchestrator {
         return childProcess;
     }
     // endregion Single Task
+    // region Readiness
+    getReadyWhen(task, env, inputs) {
+        return (0, ready_when_1.getReadyWhen)(task, this.projectGraph, this.projects, workspace_root_1.workspaceRoot, env, inputs);
+    }
+    // NX_READY_URL is known only after the wait, so fail now only when the
+    // check fails without it and, if a producer may report one, with a URL too
+    checkReadyWhenBeforeWait(task, env, inputs) {
+        const producerIds = (0, ready_when_1.getReadyProducerIds)(task, this.fullTaskGraph);
+        if (!inputs || !producerIds.length) {
+            return;
+        }
+        const envs = [env];
+        if (producerIds.some((id) => (0, ready_when_1.mayReportReadyUrl)(this.fullTaskGraph.tasks[id], this.projectGraph))) {
+            envs.push({ ...env, [ready_signal_1.READY_URL_ENV]: 'http://localhost/' });
+        }
+        const errors = envs.map((checkEnv) => {
+            try {
+                this.getReadyWhen(task, checkEnv, inputs);
+                return null;
+            }
+            catch (e) {
+                return e;
+            }
+        });
+        if (errors.every(Boolean)) {
+            this.getReadinessCheck(task, () => {
+                throw errors[errors.length - 1];
+            });
+        }
+    }
+    // Only the process that runs a producer knows the env its probe reads
+    getReadyWhenWait(task) {
+        return (0, ready_when_1.getReadyWhenWait)(task, this.projectGraph, this.projects, workspace_root_1.workspaceRoot);
+    }
+    // An invalid readyWhen fails the task before it starts only when something
+    // in this run waits for it; otherwise the task runs without a check
+    getReadinessCheck(task, resolve) {
+        try {
+            const readyWhen = resolve();
+            return {
+                readyWhen,
+                // A readyWhen resolves to no check when the server picks its port
+                readyOnStart: readyWhen === null &&
+                    (0, ready_when_1.getReadyWhenConfig)(task, this.projectGraph) != null,
+            };
+        }
+        catch (e) {
+            if (!(e instanceof ready_when_1.InvalidReadyWhenError) ||
+                this.hasReadyWaiter(task.id)) {
+                throw e;
+            }
+            return { readyWhen: null, uncheckedReason: e.message };
+        }
+    }
+    // Call it after the start: the TUI replaces the task's terminal when it
+    // starts, dropping output appended before
+    warnUncheckedReadiness(task, reason) {
+        const message = `${reason} Nothing in this run waits for it to be ready, so it runs without a readiness check.`;
+        if (this.tuiEnabled) {
+            this.options.lifeCycle.appendTaskOutput(task.id, `\r\n${message}\r\n`, false);
+        }
+        else {
+            console.warn(message);
+        }
+    }
+    async waitForReadyDependencies(task) {
+        const producerIds = (0, ready_when_1.getReadyProducerIds)(task, this.fullTaskGraph);
+        for (const producerId of producerIds) {
+            const producer = this.fullTaskGraph.tasks[producerId];
+            let readyWhen;
+            try {
+                readyWhen = this.getReadyWhenWait(producer);
+            }
+            catch (e) {
+                // An owner in another process runs it unchecked and marks its row
+                // failed, or drops the row. Without a row, nothing will settle it.
+                if (!(e instanceof ready_when_1.InvalidReadyWhenError) ||
+                    this.taskGraph.tasks[producerId]) {
+                    throw e;
+                }
+                const owned = await this.pollReadinessRow(producer, { timeout: ready_when_1.DEFAULT_READY_TIMEOUT, description: 'invalid' }, { onPending: () => this.onReadinessHold(producerId) });
+                if (!owned) {
+                    throw e;
+                }
+                continue;
+            }
+            if (!readyWhen) {
+                if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                    console.log(`Task "${producer.id}" declares no "readyWhen", so "${task.id}" runs once it has started.`);
+                }
+                continue;
+            }
+            // A producer in this task graph is held by dispatch and settled by its
+            // probe or row poll; one outside it (an agent's flat graph) has only its row
+            if (this.taskGraph.tasks[producerId]) {
+                await this.readinessOf(producerId).promise;
+            }
+            else {
+                await this.pollReadinessRow(producer, readyWhen, {
+                    onPending: () => this.onReadinessHold(producerId),
+                });
+            }
+        }
+    }
+    // A waiter learns the url of the one ready producer that reported it
+    getReadyUrlEnv(task) {
+        const urls = (0, ready_when_1.getReadyProducerIds)(task, this.fullTaskGraph)
+            .map((id) => this.readyUrls.get(id))
+            .filter(Boolean);
+        return urls.length === 1 ? { [ready_signal_1.READY_URL_ENV]: urls[0] } : {};
+    }
+    onReadinessHold(producerId) {
+        if (!this.waitingLogged.has(producerId) &&
+            !this.tuiEnabled &&
+            (0, output_1.printsTaskOutput)(this.resolvedOutputStyle)) {
+            this.waitingLogged.add(producerId);
+            console.log(`Waiting for "${producerId}" to be ready...`);
+        }
+    }
+    // A row absent from the start means no Nx process this one can see owns the
+    // producer (resolves false), unless the caller already saw the owner: then it
+    // exited. A row that disappears mid-wait means the producer exited.
+    async pollReadinessRow(producer, readyWhen, { signal, ownerObserved = false, onPending, } = {}) {
+        const deadline = Date.now() + readyWhen.timeout;
+        let lastStatus = null;
+        while (true) {
+            if (signal?.aborted) {
+                throw (0, ready_when_1.notReadyError)(producer.id, 'exited');
+            }
+            if (this.stopRequested || this.bailed) {
+                throw (0, ready_when_1.notReadyError)(producer.id, 'was stopped');
+            }
+            const status = this.runningTasksService?.getTaskReadiness(producer.id) ?? null;
+            if (status === null) {
+                if (lastStatus !== null || ownerObserved) {
+                    throw (0, ready_when_1.notReadyError)(producer.id, 'exited');
+                }
+                return false;
+            }
+            if (status !== lastStatus) {
+                lastStatus = status;
+                this.options.lifeCycle.setTaskReadiness?.(producer.id, status);
+            }
+            if (status === 1 /* TaskReadiness.Ready */) {
+                this.readReadyUrl(producer.id);
+                return true;
+            }
+            if (status === 2 /* TaskReadiness.Failed */) {
+                throw new ready_when_1.ProducerFailedError(producer.id);
+            }
+            if (Date.now() >= deadline) {
+                throw (0, ready_when_1.readinessTimeoutError)(producer.id, readyWhen);
+            }
+            onPending?.();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+    }
+    startReadinessProbe(task, readyWhen, runningTask) {
+        const state = this.armReadiness(task.id);
+        this.options.lifeCycle.setTaskReadiness?.(task.id, 0 /* TaskReadiness.Pending */);
+        (0, probes_1.waitForReadiness)(readyWhen, {
+            taskId: task.id,
+            runningTask,
+            cwd: workspace_root_1.workspaceRoot,
+            signal: state.abort.signal,
+            readySignal: this.readySignal,
+        }).then(({ url }) => {
+            if (state.abort.signal.aborted)
+                return;
+            if (url)
+                this.readyUrls.set(task.id, url);
+            this.recordReadiness(task, 1 /* TaskReadiness.Ready */, url);
+            state.resolve();
+        }, (e) => {
+            if (state.abort.signal.aborted)
+                return;
+            this.recordReadiness(task, 2 /* TaskReadiness.Failed */);
+            this.failReadiness(task, state, e);
+        });
+    }
+    // A verdict against a producer something in this run waits for fails the
+    // producer, and the skip propagation covers the waiters. Without a waiter
+    // the producer is left alone, as a plain `nx serve` with a probe would be.
+    async failReadiness(task, state, e) {
+        const message = e?.message ?? String(e);
+        const entry = this.runningContinuousTasks.get(task.id);
+        if (entry &&
+            !(e instanceof ready_when_1.NotReadyError) &&
+            this.hasReadyWaiter(task.id)) {
+            if (this.tuiEnabled) {
+                this.options.lifeCycle.appendTaskOutput(task.id, `\r\n${message}\r\n`, false);
+            }
+            else {
+                console.error(message);
+            }
+            this.readinessFailureReasons.set(task.id, message);
+            const completion = this.complete([{ task, status: 'failure', terminalOutput: message }], entry.groupId);
+            this.readinessFailures.set(task.id, completion);
+            try {
+                await completion;
+            }
+            finally {
+                this.readinessFailures.delete(task.id);
+            }
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(message);
+        }
+        state.reject(e);
+    }
+    // On an agent the waiter runs in another process with its own flat graph
+    hasReadyWaiter(producerId) {
+        return Object.values(this.fullTaskGraph.tasks).some((task) => (0, ready_when_1.getReadyProducerIds)(task, this.fullTaskGraph).includes(producerId));
+    }
+    // The producer is not in this task graph, so no skip propagates to the waiter
+    async skipWaiter(task, groupId) {
+        if (!this.completedTasks.has(task.id)) {
+            await this.complete([{ task, status: 'skipped' }], groupId);
+        }
+    }
+    recordReadiness(task, status, url) {
+        this.options.lifeCycle.setTaskReadiness?.(task.id, status);
+        this.publishReadiness(task, status, url);
+    }
+    // Only other processes read the row, so a failed write must not fail this one
+    publishReadiness(task, status, url) {
+        try {
+            this.runningTasksService?.setTaskReadiness(task.id, status, url ?? null);
+        }
+        catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(`Failed to record readiness of "${task.id}":`, e);
+            }
+        }
+    }
+    // The url a producer another process runs reported with its readiness
+    readReadyUrl(producerId) {
+        try {
+            const url = this.runningTasksService?.getTaskReadyUrl(producerId);
+            if (url)
+                this.readyUrls.set(producerId, url);
+        }
+        catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(`Failed to read the url of "${producerId}":`, e);
+            }
+        }
+    }
+    readinessOf(taskId) {
+        return this.readiness.get(taskId) ?? this.armReadiness(taskId);
+    }
+    // Replaces a state settled by an earlier run so a restart re-arms it
+    armReadiness(taskId) {
+        let state = this.readiness.get(taskId);
+        if (!state || state.settled) {
+            this.tasksSchedule.markReadinessPending(taskId);
+            state = createReadinessState((outcome) => {
+                if (outcome === 'ready') {
+                    this.tasksSchedule.markReady(taskId);
+                }
+                else {
+                    this.tasksSchedule.markReadinessFailed(taskId);
+                }
+                this.readinessSettled = true;
+                this.releaseThreads();
+            });
+            this.readiness.set(taskId, state);
+        }
+        return state;
+    }
+    abortReadiness(taskId, reason) {
+        const state = this.readiness.get(taskId);
+        if (!state)
+            return;
+        state.abort.abort();
+        state.reject((0, ready_when_1.notReadyError)(taskId, reason));
+    }
+    abortAllReadiness() {
+        for (const taskId of this.readiness.keys()) {
+            this.abortReadiness(taskId, 'was stopped');
+        }
+    }
+    async failTaskBeforeStart(task, groupId, e, doNotSkipCache = false) {
+        this.abortReadiness(task.id, 'failed');
+        // Already skipped by a failed dependency's propagation
+        if (!this.completedTasks.has(task.id)) {
+            // Lifecycles pair endTasks with startTasks, so start it before failing it
+            await this.preRunSteps([task], { groupId });
+            await this.handleDiscreteWorkerFailure(doNotSkipCache, task, groupId, e);
+        }
+        return new noop_child_process_1.NoopChildProcess({ code: 1, terminalOutput: e?.message ?? '' });
+    }
+    // endregion Readiness
     // region Lifecycle
     async preRunSteps(tasks, metadata) {
         const now = Date.now();
@@ -1364,7 +1931,13 @@ class TaskOrchestrator {
         if (!task.hash)
             return;
         try {
-            const { size } = (0, fs_1.statSync)(this.cache.temporaryOutputPath(task));
+            const outputPath = this.cache.temporaryOutputPath(task);
+            // The runner's exit handler wrote the child's transcript alone
+            const reason = this.readinessFailureReasons.get(task.id);
+            if (reason) {
+                (0, fs_1.appendFileSync)(outputPath, `\n${reason}\n`);
+            }
+            const { size } = (0, fs_1.statSync)(outputPath);
             this.cache.recordTerminalOutputs([{ hash: task.hash, size }]);
         }
         catch {
@@ -1373,12 +1946,13 @@ class TaskOrchestrator {
     }
     async scheduleNextTasksAndReleaseThreads() {
         if (this.stopRequested) {
-            this.waitingForTasks.forEach((f) => f(null));
-            this.waitingForTasks.length = 0;
+            this.releaseThreads();
             return;
         }
         await this.tasksSchedule.scheduleNextTasks();
-        // release blocked threads
+        this.releaseThreads();
+    }
+    releaseThreads() {
         this.waitingForTasks.forEach((f) => f(null));
         this.waitingForTasks.length = 0;
     }
@@ -1425,8 +1999,7 @@ class TaskOrchestrator {
             if (this.completedTasks.has(task.id))
                 continue;
             this.completedTasks.set(task.id, status);
-            this.taskInvocationTracker?.unregisterTask(task.id);
-            this.registeredInvocations.delete(task.id);
+            this.releaseTaskInvocation(task);
             if (this.tuiEnabled) {
                 this.options.lifeCycle.setTaskStatus(task.id, displayStatus ?? (0, native_1.parseTaskStatus)(status));
             }
@@ -1437,6 +2010,7 @@ class TaskOrchestrator {
                     // mark the execution as bailed which will stop all further execution
                     // only the tasks that are currently running will finish
                     this.bailed = true;
+                    this.abortAllReadiness();
                 }
                 else {
                     // Collect reverse deps to skip
@@ -1467,6 +2041,14 @@ class TaskOrchestrator {
             if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false') {
                 return true;
             }
+            // The log probe reads the captured output. Read from the config, because
+            // the probe resolves against the env that depends on this
+            const readyWhen = (0, ready_when_1.getReadyWhenConfig)(task, this.projectGraph);
+            if (typeof readyWhen === 'object' &&
+                readyWhen &&
+                'logMatches' in readyWhen) {
+                return true;
+            }
             // When TUI is enabled, we need to use pipe output capture to support
             // progressive output streaming via the onOutput callback
             if (this.tuiEnabled) {
@@ -1520,8 +2102,13 @@ class TaskOrchestrator {
     }
     // endregion utils
     async handleContinuousTaskExit(code, task, groupId, ownsRunningTasksService) {
-        // If cleanup already completed this task, nothing left to do
+        await this.readinessFailures.get(task.id);
+        // Completed by cleanup, or failed its readiness check while still running
         if (this.completedTasks.has(task.id)) {
+            if (this.runningContinuousTasks.delete(task.id) &&
+                ownsRunningTasksService) {
+                this.runningTasksService?.removeRunningTask(task.id);
+            }
             return;
         }
         const stoppingReason = this.runningContinuousTasks.get(task.id)?.stoppingReason;
@@ -1542,15 +2129,20 @@ class TaskOrchestrator {
     isContinuousTaskNeeded(taskId) {
         return this.tasksSchedule
             .getIncompleteTasks()
-            .some((t) => this.taskGraph.continuousDependencies[t.id]?.includes(taskId));
+            .some((t) => this.taskGraph.continuousDependencies[t.id]?.some((edge) => edge.id === taskId));
     }
     async completeContinuousTask(task, groupId, ownsRunningTasksService, reason) {
-        if (this.completedTasks.has(task.id))
-            return;
+        await this.readinessFailures.get(task.id);
         this.runningContinuousTasks.delete(task.id);
         if (ownsRunningTasksService) {
             this.runningTasksService?.removeRunningTask(task.id);
         }
+        // A probe that does not need the child (url, port, command) could still
+        // pass during completion and release dependents of an exited producer
+        this.readiness.get(task.id)?.abort.abort();
+        // Failed its readiness check while still running
+        if (this.completedTasks.has(task.id))
+            return;
         task.endTime = Date.now();
         if (reason === 'fulfilled') {
             await this.complete([
@@ -1567,6 +2159,11 @@ class TaskOrchestrator {
         else {
             await this.complete([{ task, status: 'stopped' }], groupId);
         }
+        // After the skip propagation above, so a waiter is reported as skipped
+        // rather than as failed
+        this.abortReadiness(task.id, 'exited');
+        // Skipped dependents leave nothing in flight to wake the loops
+        this.releaseThreads();
     }
     async cleanup() {
         if (this.cleanupPromise) {
@@ -1576,6 +2173,9 @@ class TaskOrchestrator {
         return this.cleanupPromise;
     }
     async performCleanup() {
+        // Waiters must not sit out a probe once the run is stopping
+        this.abortAllReadiness();
+        this.readySignal?.close();
         // Mark all running tasks for intentional stop
         const reason = this.stopRequested ? 'interrupted' : 'fulfilled';
         for (const entry of this.runningContinuousTasks.values()) {
@@ -1716,7 +2316,7 @@ class TaskOrchestrator {
             }
             const continuousDependencies = this.taskGraph.continuousDependencies[task.id];
             for (const continuousDependency of continuousDependencies) {
-                neededContinuousTasks.add(continuousDependency);
+                neededContinuousTasks.add(continuousDependency.id);
             }
         }
         for (const [taskId, entry] of this.runningContinuousTasks) {