@rushstack/rush-sdk 5.170.1-pr5378.0 → 5.171.0

package/dist/rush-lib.d.ts

@@ -31,7 +31,6 @@ import type { StdioSummarizer } from '@rushstack/terminal';
 import { SyncHook } from 'tapable';
 import { SyncWaterfallHook } from 'tapable';
 import { Terminal } from '@rushstack/terminal';
-import type { TerminalWritable } from '@rushstack/terminal';
 
 /**
  * This represents the JSON file specified via the "approvedPackagesFile" option in rush.json.
@@ -883,7 +882,7 @@ export declare const EnvironmentVariableNames: {
 };
 
 /**
- * Events happen during Rush invocation.
+ * Events happen during Rush runs.
  * @beta
  */
 declare enum Event_2 {
@@ -1055,31 +1054,6 @@ declare interface IBaseBuildCacheJson {
     cacheHashSalt?: string;
 }
 
-/**
- * @alpha
- */
-export declare interface IBaseOperationExecutionResult {
-    /**
-     * The operation itself
-     */
-    readonly operation: Operation;
-    /**
-     * The relative path to the folder that contains operation metadata. This folder will be automatically included in cache entries.
-     */
-    readonly metadataFolderPath: string;
-    /**
-     * Gets the hash of the state of all registered inputs to this operation.
-     * Calling this method will throw if Git is not available.
-     */
-    getStateHash(): string;
-    /**
-     * Gets the structured components of the state hash. This is useful for debugging and
-     * incremental change detection.
-     * Calling this method will throw if Git is not available.
-     */
-    getStateHashComponents(): IOperationStateHashComponents;
-}
-
 /**
  * @beta
  */
@@ -1220,18 +1194,6 @@ export declare interface ICobuildLockProvider {
     getCompletedStateAsync(context: Readonly<ICobuildContext>): Promise<ICobuildCompletedState | undefined>;
 }
 
-/**
- * The `IConfigurableOperation` interface represents an {@link Operation} whose
- * execution can be configured before running.
- * @alpha
- */
-export declare interface IConfigurableOperation extends IBaseOperationExecutionResult {
-    /**
-     * True if the operation should execute in this iteration, false otherwise.
-     */
-    enabled: boolean;
-}
-
 /**
  * A collection of environment variables
  * @public
@@ -1284,15 +1246,16 @@ export declare interface ICreateOperationsContext {
      * Maps from the `longName` field in command-line.json to the parser configuration in ts-command-line.
      */
     readonly customParameters: ReadonlyMap<string, CommandLineParameter>;
-    /**
-     * If true, dependencies of the selected phases will be automatically enabled in the execution.
-     */
-    readonly includePhaseDeps: boolean;
     /**
      * If true, projects may read their output from cache or be skipped if already up to date.
      * If false, neither of the above may occur, e.g. "rush rebuild"
      */
     readonly isIncrementalBuildAllowed: boolean;
+    /**
+     * If true, this is the initial run of the command.
+     * If false, this execution is in response to changes.
+     */
+    readonly isInitial: boolean;
     /**
      * If true, the command is running in watch mode.
      */
@@ -1300,28 +1263,45 @@ export declare interface ICreateOperationsContext {
     /**
      * The currently configured maximum parallelism for the command.
      */
-    readonly parallelism: Parallelism;
+    readonly parallelism: number;
     /**
-     * The set of phases selected for execution.
+     * The set of phases original for the current command execution.
      */
-    readonly phaseSelection: ReadonlySet<IPhase>;
+    readonly phaseOriginal: ReadonlySet<IPhase>;
     /**
-     * All successfully loaded rush-project.json data for selected projects.
+     * The set of phases selected for the current command execution.
      */
-    readonly projectConfigurations: ReadonlyMap<RushConfigurationProject, RushProjectConfiguration>;
+    readonly phaseSelection: ReadonlySet<IPhase>;
     /**
-     * The set of Rush projects selected for execution.
+     * The set of Rush projects selected for the current command execution.
      */
     readonly projectSelection: ReadonlySet<RushConfigurationProject>;
     /**
-     * If true, the operation graph should include all projects in the repository (watch broad graph mode).
-     * Only the projects in projectSelection should start enabled; others are present but disabled.
+     * All successfully loaded rush-project.json data for selected projects.
      */
-    readonly generateFullGraph?: boolean;
+    readonly projectConfigurations: ReadonlyMap<RushConfigurationProject, RushProjectConfiguration>;
+    /**
+     * The set of Rush projects that have not been built in the current process since they were last modified.
+     * When `isInitial` is true, this will be an exact match of `projectSelection`.
+     */
+    readonly projectsInUnknownState: ReadonlySet<RushConfigurationProject>;
     /**
      * The Rush configuration
      */
     readonly rushConfiguration: RushConfiguration;
+    /**
+     * If true, Rush will automatically include the dependent phases for the specified set of phases.
+     * @remarks
+     * If the selection of projects was "unsafe" (i.e. missing some dependencies), this will add the
+     * minimum number of phases required to make it safe.
+     */
+    readonly includePhaseDeps: boolean;
+    /**
+     * Marks an operation's result as invalid, potentially triggering a new build. Only applicable in watch mode.
+     * @param operation - The operation to invalidate
+     * @param reason - The reason for invalidating the operation
+     */
+    readonly invalidateOperation?: ((operation: Operation, reason: string) => void) | undefined;
 }
 
 export { ICredentialCacheEntry }
@@ -1419,6 +1399,22 @@ declare interface IEventHooksJson {
     postRushBuild?: string[];
 }
 
+/**
+ * Context used for executing operations.
+ * @alpha
+ */
+export declare interface IExecuteOperationsContext extends ICreateOperationsContext {
+    /**
+     * The current state of the repository, if available.
+     * Not part of the creation context to avoid the overhead of Git calls when initializing the graph.
+     */
+    readonly inputsSnapshot?: IInputsSnapshot;
+    /**
+     * An abort controller that can be used to abort the current set of queued operations.
+     */
+    readonly abortController: AbortController;
+}
+
 /**
  * The `IExecutionResult` interface represents the results of executing a set of {@link Operation}s.
  * @alpha
@@ -1836,7 +1832,11 @@ export declare interface _IOperationBuildCacheOptions {
  * The `IOperationExecutionResult` interface represents the results of executing an {@link Operation}.
  * @alpha
  */
-export declare interface IOperationExecutionResult extends IBaseOperationExecutionResult, IOperationLastState {
+export declare interface IOperationExecutionResult {
+    /**
+     * The operation itself
+     */
+    readonly operation: Operation;
     /**
      * The current execution status of an operation. Operations start in the 'ready' state,
      * but can be 'blocked' if an upstream operation failed. It is 'executing' when
@@ -1853,10 +1853,6 @@ export declare interface IOperationExecutionResult extends IBaseOperationExecuti
      * If this operation is only present in the graph to maintain dependency relationships, this flag will be set to true.
      */
     readonly silent: boolean;
-    /**
-     * True if the operation should execute in this iteration, false otherwise.
-     */
-    readonly enabled: boolean;
     /**
      * Object tracking execution timing.
      */
@@ -1874,164 +1870,23 @@ export declare interface IOperationExecutionResult extends IBaseOperationExecuti
      */
     readonly nonCachedDurationMs: number | undefined;
     /**
-     * The paths to the log files, if applicable.
-     */
-    readonly logFilePaths: ILogFilePaths | undefined;
-}
-
-/**
- * Public API for the operation graph.
- * @alpha
- */
-export declare interface IOperationGraph {
-    /**
-     * Hooks into the execution process for operations
-     */
-    readonly hooks: OperationGraphHooks;
-    /**
-     * The set of operations in the graph.
-     */
-    readonly operations: ReadonlySet<Operation>;
-    /**
-     * A map from each `Operation` in the graph to its current result record.
-     * The map is updated in real time as operations execute during an iteration.
-     * Only statuses representing a completed execution (e.g. `Success`, `Failure`,
-     * `SuccessWithWarning`) write to this map; statuses such as `Skipped` or `Aborted` —
-     * which indicate that an operation did not actually run — do not update it.
-     * For operations that have not yet run in the current iteration, the map retains the
-     * result from whichever prior iteration the operation last ran in.
-     * An entry with status `Ready` indicates that the operation is considered stale and
-     * has been queued to run again.
-     * Empty until at least one operation has completed execution.
-     */
-    readonly resultByOperation: ReadonlyMap<Operation, IOperationExecutionResult>;
-    /**
-     * The maximum allowed parallelism for this operation graph.
-     * Reads as a concrete integer. Accepts a `Parallelism` value and coerces it on write.
-     */
-    get parallelism(): number;
-    set parallelism(value: Parallelism);
-    /**
-     * If additional debug information should be printed during execution.
-     */
-    debugMode: boolean;
-    /**
-     * If true, operations will be executed in "quiet mode" where only errors are reported.
-     */
-    quietMode: boolean;
-    /**
-     * If true, allow operations to oversubscribe the CPU. Defaults to true.
-     */
-    allowOversubscription: boolean;
-    /**
-     * When true, the operation graph will pause before running the next iteration (manual mode).
-     * When false, iterations run automatically when scheduled.
-     */
-    pauseNextIteration: boolean;
-    /**
-     * The current overall status of the execution.
-     */
-    readonly status: OperationStatus;
-    /**
-     * The current set of terminal destinations.
-     */
-    readonly terminalDestinations: ReadonlySet<TerminalWritable>;
-    /**
-     * True if there is a scheduled (but not yet executing) iteration.
-     * This will be false while an iteration is actively executing, or when no work is scheduled.
-     */
-    readonly hasScheduledIteration: boolean;
-    /**
-     * AbortController controlling the lifetime of the overall session (e.g. watch mode).
-     * Aborting this controller should signal all listeners (such as file system watchers) to dispose
-     * and prevent further iterations from being scheduled.
-     */
-    readonly abortController: AbortController;
-    /**
-     * Abort the current execution iteration, if any. Operations that have already started
-     * will run to completion; only operations that have not yet begun will be aborted.
-     */
-    abortCurrentIterationAsync(): Promise<void>;
-    /**
-     * Cleans up any resources used by the operation runners, if applicable.
-     * @param operations - The operations whose runners should be closed, or undefined to close all runners.
-     */
-    closeRunnersAsync(operations?: Iterable<Operation>): Promise<void>;
-    /**
-     * Executes a single iteration of the operations.
-     * @param options - Options for this execution iteration.
-     * @returns A promise that resolves to true if the iteration has work to be done, or false if the iteration was empty and therefore not scheduled.
-     */
-    scheduleIterationAsync(options: IOperationGraphIterationOptions): Promise<boolean>;
-    /**
-     * Executes all operations in the currently scheduled iteration, if any.
-     * @returns A promise which is resolved when all operations have been processed to a final state.
-     */
-    executeScheduledIterationAsync(): Promise<boolean>;
-    /**
-     * Invalidates the specified operations, causing them to be re-executed.
-     * @param operations - The operations to invalidate, or undefined to invalidate all operations.
-     * @param reason - Optional reason for invalidation.
-     */
-    invalidateOperations(operations?: Iterable<Operation>, reason?: string): void;
-    /**
-     * Sets the enabled state for a collection of operations.
-     *
-     * @param operations - The operations whose enabled state should be updated.
-     * @param targetState - The target enabled state to apply.
-     * @param mode - 'unsafe' to directly mutate only the provided operations, 'safe' to also enable
-     * transitive dependencies of enabled operations and disable transitive dependents of disabled operations.
-     * @returns true if any operation's enabled state changed, false otherwise.
-     */
-    setEnabledStates(operations: Iterable<Operation>, targetState: Operation['enabled'], mode: 'safe' | 'unsafe'): boolean;
-    /**
-     * Adds a terminal destination for output. Only new output will be sent to the destination.
-     * @param destination - The destination to add.
-     */
-    addTerminalDestination(destination: TerminalWritable): void;
-    /**
-     * Removes a terminal destination for output. Optionally closes the stream.
-     * New output will no longer be sent to the destination.
-     * @param destination - The destination to remove.
-     * @param close - Whether to close the stream. Defaults to `true`.
+     * The relative path to the folder that contains operation metadata. This folder will be automatically included in cache entries.
      */
-    removeTerminalDestination(destination: TerminalWritable, close?: boolean): boolean;
-}
-
-/**
- * Context used for configuring the operation graph.
- * @alpha
- */
-export declare interface IOperationGraphContext extends ICreateOperationsContext {
+    readonly metadataFolderPath: string | undefined;
     /**
-     * The current state of the repository, if available.
-     * Not part of the creation context to avoid the overhead of Git calls when initializing the graph.
+     * The paths to the log files, if applicable.
      */
-    readonly initialSnapshot?: IInputsSnapshot;
-}
-
-/**
- * Options for a single iteration of operation execution.
- * @alpha
- */
-export declare interface IOperationGraphIterationOptions {
-    inputsSnapshot?: IInputsSnapshot;
+    readonly logFilePaths: ILogFilePaths | undefined;
     /**
-     * The time when the iteration was scheduled, if available, as returned by `performance.now()`.
+     * Gets the hash of the state of all registered inputs to this operation.
+     * Calling this method will throw if Git is not available.
      */
-    startTime?: number;
-}
-
-/**
- * A snapshot of a previous operation execution, passed to runners to inform incremental behavior.
- *
- * @beta
- */
-export declare interface IOperationLastState {
+    getStateHash(): string;
     /**
-     * The status from the previous execution of this operation.
+     * Gets the components of the state hash. This is useful for debugging purposes.
+     * Calling this method will throw if Git is not available.
      */
-    readonly status: OperationStatus;
+    getStateHashComponents(): ReadonlyArray<string>;
 }
 
 /**
@@ -2066,18 +1921,6 @@ export declare interface IOperationOptions {
      * The Rush project associated with this Operation
      */
     project: RushConfigurationProject;
-    /**
-     * If set to false, this operation will be skipped during evaluation (return OperationStatus.Skipped).
-     * This is useful for plugins to alter the scope of the operation graph across executions,
-     * e.g. to enable or disable unit test execution, or to include or exclude dependencies.
-     *
-     * The special value "ignore-dependency-changes" can be used to indicate that this operation should only
-     * be executed if there are local changes in the project. This is useful for operations like
-     * "test" where you may want to skip testing projects that haven't changed.
-     *
-     * The default value is `true`, meaning the operation will be executed if it or any dependencies change.
-     */
-    enabled?: OperationEnabledState;
     /**
      * When the scheduler is ready to process this `Operation`, the `runner` implements the actual work of
      * running the operation.
@@ -2095,7 +1938,7 @@ export declare interface IOperationOptions {
 
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
- * `OperationGraph`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
+ * `OperationExecutionManager`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
  * implementation manages the actual process for running a single operation.
  *
  * @beta
@@ -2127,27 +1970,14 @@ export declare interface IOperationRunner {
      * analysis purposes.
      */
     readonly isNoOp?: boolean;
-    /**
-     * If true, this runner currently owns some kind of active resource (e.g. a service or a watch process).
-     * This can be used to determine if the operation is "in progress" even if it is not currently executing.
-     * If the runner supports this property, it should update it as appropriate during execution.
-     * The property is optional to avoid breaking existing implementations of IOperationRunner.
-     */
-    readonly isActive?: boolean;
     /**
      * Method to be executed for the operation.
-     * @param context - The context object containing information about the execution environment.
-     * @param lastState - The last execution result of this operation, if any.
      */
-    executeAsync(context: IOperationRunnerContext, lastState?: IOperationLastState): Promise<OperationStatus>;
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     /**
      * Return a hash of the configuration that affects the operation.
      */
     getConfigHash(): string;
-    /**
-     * If this runner performs any background work to optimize future runs, this method will clean it up.
-     */
-    closeAsync?(): Promise<void>;
 }
 
 /**
@@ -2195,12 +2025,6 @@ export declare interface IOperationRunnerContext {
      * it later (for example to re-print errors at end of execution).
      */
     error?: Error;
-    /**
-     * Returns a callback that invalidates this operation so that it will be re-executed in the next iteration.
-     * The returned callback captures only the minimal state needed, avoiding retention of the full context.
-     * Callers should store the result rather than calling this method repeatedly.
-     */
-    getInvalidateCallback(): (reason: string) => void;
     /**
      * Invokes the specified callback with a terminal that is associated with this operation.
      *
@@ -2308,26 +2132,6 @@ export declare interface _IOperationStateFileOptions {
     metadataFolder: string;
 }
 
-/**
- * Structured components of the state hash for an operation.
- * @alpha
- */
-export declare interface IOperationStateHashComponents {
-    /**
-     * The state hashes of operation dependencies, sorted by name.
-     * Each entry is of the form `{dependencyName}={hash}`.
-     */
-    readonly dependencies: readonly string[];
-    /**
-     * The hash of the operation's own local inputs (e.g. tracked files, environment variables).
-     */
-    readonly local: string;
-    /**
-     * The hash of the operation's configuration (e.g. CLI parameters).
-     */
-    readonly config: string;
-}
-
 /**
  * @internal
  */
@@ -2348,14 +2152,6 @@ export declare interface IPackageManagerOptionsJsonBase {
     environmentVariables?: IConfigurationEnvironment;
 }
 
-/**
- * A parallelism value expressed as a fraction of total available concurrency slots.
- * @beta
- */
-export declare interface IParallelismScalar {
-    readonly scalar: number;
-}
-
 /**
  * Metadata about a phase.
  * @alpha
@@ -2431,17 +2227,6 @@ export declare interface IPhasedCommand extends IRushCommand {
     readonly sessionAbortController: AbortController;
 }
 
-/**
- * A plugin that interacts with a phased commands.
- * @alpha
- */
-export declare interface IPhasedCommandPlugin {
-    /**
-     * Applies this plugin.
-     */
-    apply(hooks: PhasedCommandHooks): void;
-}
-
 /**
  * Possible values for the `pnpmLockfilePolicies` setting in Rush's pnpm-config.json file.
  * @public
@@ -3169,7 +2954,7 @@ export declare class NpmOptionsConfiguration extends PackageManagerOptionsConfig
 
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
- * `OperationGraph`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
+ * `OperationExecutionManager`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
  * implementation manages the actual process of running a single operation.
  *
  * The graph of `Operation` instances will be cloned into a separate execution graph after processing.
@@ -3205,23 +2990,17 @@ export declare class Operation {
      */
     runner: IOperationRunner | undefined;
     /**
-     * The concurrency weight for this operation. When coerced to an integer via `coerceParallelism`,
-     * this value represents how many concurrency slots the operation consumes while running.
-     *
-     * May be specified as:
-     * - A raw `number`: used directly as the slot count (e.g. `2` consumes two slots).
-     * - An `IParallelismScalar` (e.g. `{ scalar: 0.5 }`): coerced relative to the graph's
-     *   configured `maxParallelism` at execution time, so the weight scales with the available
-     *   concurrency rather than being fixed at parse time.
-     *
-     * Coerced values guide scheduling as follows:
-     * - `1` slot: typical operation consuming one logical thread.
-     * - `> 1` slots: operation that spawns multiple threads or requires significant RAM; reserving
-     *   extra slots prevents overloading the machine (e.g. a whole-program bundler or a test suite
-     *   that runs its own internal parallelism).
-     * - `0` slots: effectively free (e.g. a no-op or cache-restore step).
+     * The weight for this operation. This scalar is the contribution of this operation to the
+     * `criticalPathLength` calculation above. Modify to indicate the following:
+     * - `weight` === 1: indicates that this operation has an average duration
+     * - `weight` &gt; 1: indicates that this operation takes longer than average and so the scheduler
+     *     should try to favor starting it over other, shorter operations. An example might be an operation that
+     *     bundles an entire application and runs whole-program optimization.
+     * - `weight` &lt; 1: indicates that this operation takes less time than average and so the scheduler
+     *     should favor other, longer operations over it. An example might be an operation to unpack a cached
+     *     output, or an operation using NullOperationRunner, which might use a value of 0.
      */
-    weight: Parallelism;
+    weight: number;
     /**
      * Get the operation settings for this operation, defaults to the values defined in
      *  the project configuration.
@@ -3231,14 +3010,8 @@ export declare class Operation {
      * If set to false, this operation will be skipped during evaluation (return OperationStatus.Skipped).
      * This is useful for plugins to alter the scope of the operation graph across executions,
      * e.g. to enable or disable unit test execution, or to include or exclude dependencies.
-     *
-     * The special value "ignore-dependency-changes" can be used to indicate that this operation should only
-     * be executed if there are local changes in the project. This is useful for operations like
-     * "test" where you may want to skip testing projects that haven't changed.
-     *
-     * The default value is `true`, meaning the operation will be executed if it or any dependencies change.
      */
-    enabled: OperationEnabledState;
+    enabled: boolean;
     constructor(options: IOperationOptions);
     /**
      * The name of this operation, for logging.
@@ -3275,7 +3048,7 @@ export declare class _OperationBuildCache {
     private static _tryGetTarUtility;
     get cacheId(): string | undefined;
     static getOperationBuildCache(options: _IProjectBuildCacheOptions): _OperationBuildCache;
-    static forOperation(executionResult: IBaseOperationExecutionResult, options: _IOperationBuildCacheOptions): _OperationBuildCache;
+    static forOperation(executionResult: IOperationExecutionResult, options: _IOperationBuildCacheOptions): _OperationBuildCache;
     tryRestoreFromCacheAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     trySetCacheEntryAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     /**
@@ -3288,139 +3061,6 @@ export declare class _OperationBuildCache {
     private static _getCacheId;
 }
 
-/**
- * State for the `enabled` property of an `Operation`.
- *
- * - `true`: The operation should be executed if it or any dependencies changed.
- * - `false`: The operation should be skipped.
- * - `"ignore-dependency-changes"`: The operation should be executed if there are local changes in the project,
- *   otherwise it should be skipped. This is useful for operations like "test" where you may want to skip
- *   testing projects that haven't changed.
- * @alpha
- */
-export declare type OperationEnabledState = boolean | 'ignore-dependency-changes';
-
-/**
- * Hooks into the execution process for operations within the graph.
- *
- * Per-iteration lifecycle:
- * 1. `configureIteration` - Synchronously decide which operations to enable for the next iteration.
- * 2. `onIterationScheduled` - Fires after the iteration is prepared but before execution begins, if it has any enabled operations.
- * 3. `beforeExecuteIterationAsync` - Async hook that can bail out the iteration entirely.
- * 4. Operations execute (status changes reported via `onExecutionStatesUpdated`).
- * 5. `afterExecuteIterationAsync` - Fires after all operations in the iteration have settled.
- * 6. `onIdle` - Fires when the graph enters idle state awaiting changes (watch mode only).
- *
- * Additional hooks:
- * - `onEnableStatesChanged` - Fires when `setEnabledStates` mutates operation enabled flags.
- * - `onInvalidateOperations` - Fires when operations are invalidated (e.g. by file watchers).
- * - `onGraphStateChanged` - Fires on any observable graph state change.
- *
- * @alpha
- */
-export declare class OperationGraphHooks {
-    /**
-     * Hook invoked to decide what work a potential new iteration contains.
-     * Use the `lastExecutedRecords` to determine which operations are new or have had their inputs changed.
-     * Set the `enabled` states on the values in `initialRecords` to control which operations will be executed.
-     *
-     * @remarks
-     * This hook is synchronous to guarantee that the `lastExecutedRecords` map remains stable for the
-     * duration of configuration. This hook often executes while an execution iteration is currently running, so
-     * operations could complete if there were async ticks during the configuration phase.
-     *
-     * If no operations are marked for execution, the iteration will not be scheduled.
-     * If there is an existing scheduled iteration, it will remain.
-     */
-    readonly configureIteration: SyncHook<[
-    ReadonlyMap<Operation, IConfigurableOperation>,
-    ReadonlyMap<Operation, IOperationExecutionResult>,
-    IOperationGraphIterationOptions
-    ]>;
-    /**
-     * Hook invoked before operation start for an iteration. Allows a plugin to perform side-effects or
-     * short-circuit the entire iteration.
-     *
-     * If any tap returns an {@link OperationStatus}, the remaining taps are skipped and the iteration will
-     * end immediately with that status. All operations which have not yet executed will be marked
-     * Aborted.
-     */
-    readonly beforeExecuteIterationAsync: AsyncSeriesBailHook<[
-    ReadonlyMap<Operation, IOperationExecutionResult>,
-    IOperationGraphIterationOptions
-    ], OperationStatus | undefined | void>;
-    /**
-     * Batched hook invoked when one or more operation statuses have changed during the same microtask.
-     * The hook receives an array of the operation execution results that changed status.
-     * @remarks
-     * This hook is batched to reduce noise when updating many operations synchronously in quick succession.
-     */
-    readonly onExecutionStatesUpdated: SyncHook<[ReadonlySet<IOperationExecutionResult>]>;
-    /**
-     * Hook invoked when one or more operations have their enabled state mutated via
-     * {@link IOperationGraph.setEnabledStates}. Provides the set of operations whose
-     * enabled state actually changed.
-     */
-    readonly onEnableStatesChanged: SyncHook<[ReadonlySet<Operation>]>;
-    /**
-     * Hook invoked immediately after a new execution iteration is scheduled (i.e. operations selected and prepared),
-     * before any operations in that iteration have started executing. Can be used to snapshot planned work,
-     * drive UIs, or pre-compute auxiliary data.
-     */
-    readonly onIterationScheduled: SyncHook<[ReadonlyMap<Operation, IOperationExecutionResult>]>;
-    /**
-     * Hook invoked when any observable state on the operation graph changes.
-     * This includes configuration mutations (parallelism, quiet/debug modes, pauseNextIteration)
-     * as well as dynamic state (status transitions, scheduled iteration availability, etc.).
-     * Hook is series for stable output.
-     */
-    readonly onGraphStateChanged: SyncHook<[IOperationGraph]>;
-    /**
-     * Hook invoked when operations are invalidated for any reason.
-     */
-    readonly onInvalidateOperations: SyncHook<[Iterable<Operation>, string | undefined]>;
-    /**
-     * Hook invoked after an iteration has finished and the command is watching for changes.
-     * May be used to display additional relevant data to the user.
-     * Only relevant when running in watch mode.
-     */
-    readonly onIdle: SyncHook<void>;
-    /**
-     * Hook invoked after executing a set of operations.
-     * Hook is series for stable output.
-     */
-    readonly afterExecuteIterationAsync: AsyncSeriesWaterfallHook<[
-    OperationStatus,
-    ReadonlyMap<Operation, IOperationExecutionResult>,
-    IOperationGraphIterationOptions
-    ]>;
-    /**
-     * Hook invoked after executing an iteration, before the telemetry entry is written.
-     * Allows the caller to augment or modify the log entry.
-     */
-    readonly beforeLog: SyncHook<ITelemetryData, void>;
-    /**
-     * Hook invoked before executing a operation.
-     */
-    readonly beforeExecuteOperationAsync: AsyncSeriesBailHook<[
-    IOperationRunnerContext & IOperationExecutionResult
-    ], OperationStatus | undefined>;
-    /**
-     * Hook invoked to define environment variables for an operation.
-     * May be invoked by the runner to get the environment for the operation.
-     */
-    readonly createEnvironmentForOperation: SyncWaterfallHook<[
-    IEnvironment,
-    IOperationRunnerContext & IOperationExecutionResult
-    ]>;
-    /**
-     * Hook invoked after executing a operation.
-     */
-    readonly afterExecuteOperationAsync: AsyncSeriesHook<[
-    IOperationRunnerContext & IOperationExecutionResult
-    ]>;
-}
-
 /**
  * A helper class for managing the meta files of a operation.
  *
@@ -3665,34 +3305,69 @@ export declare abstract class PackageManagerOptionsConfigurationBase implements
 }
 
 /**
- * A parallelism value, either as an absolute integer count or a scalar fraction of available parallelism.
- * @beta
- */
-export declare type Parallelism = number | IParallelismScalar;
-
-/**
- * Hooks into the execution process for phased commands.
- *
- * Lifecycle:
- * 1. `createOperationsAsync` - Invoked to populate the set of operations for execution.
- * 2. `onGraphCreatedAsync` - Invoked after the operation graph is created, allowing plugins to
- *    tap into graph-level hooks (e.g. `configureIteration`, `onIdle`).
- *    See {@link OperationGraphHooks} for the per-iteration lifecycle.
- *
+ * Hooks into the execution process for phased commands
  * @alpha
  */
 export declare class PhasedCommandHooks {
     /**
      * Hook invoked to create operations for execution.
+     * Use the context to distinguish between the initial run and phased runs.
+     */
+    readonly createOperations: AsyncSeriesWaterfallHook<[Set<Operation>, ICreateOperationsContext]>;
+    /**
+     * Hook invoked before operation start
+     * Hook is series for stable output.
+     */
+    readonly beforeExecuteOperations: AsyncSeriesHook<[
+    Map<Operation, IOperationExecutionResult>,
+    IExecuteOperationsContext
+    ]>;
+    /**
+     * Hook invoked when operation status changed
+     * Hook is series for stable output.
+     */
+    readonly onOperationStatusChanged: SyncHook<[IOperationExecutionResult]>;
+    /**
+     * Hook invoked after executing a set of operations.
+     * Use the context to distinguish between the initial run and phased runs.
+     * Hook is series for stable output.
+     */
+    readonly afterExecuteOperations: AsyncSeriesHook<[IExecutionResult, IExecuteOperationsContext]>;
+    /**
+     * Hook invoked before executing a operation.
+     */
+    readonly beforeExecuteOperation: AsyncSeriesBailHook<[
+    IOperationRunnerContext & IOperationExecutionResult
+    ], OperationStatus | undefined>;
+    /**
+     * Hook invoked to define environment variables for an operation.
+     * May be invoked by the runner to get the environment for the operation.
+     */
+    readonly createEnvironmentForOperation: SyncWaterfallHook<[
+    IEnvironment,
+    IOperationRunnerContext & IOperationExecutionResult
+    ]>;
+    /**
+     * Hook invoked after executing a operation.
      */
-    readonly createOperationsAsync: AsyncSeriesWaterfallHook<[
-    Set<Operation>,
-    ICreateOperationsContext
+    readonly afterExecuteOperation: AsyncSeriesHook<[
+    IOperationRunnerContext & IOperationExecutionResult
     ]>;
     /**
-     * Hook invoked when the operation graph is created, allowing the plugin to tap into it and interact with it.
+     * Hook invoked to shutdown long-lived work in plugins.
      */
-    readonly onGraphCreatedAsync: AsyncSeriesHook<[IOperationGraph, IOperationGraphContext]>;
+    readonly shutdownAsync: AsyncParallelHook<void>;
+    /**
+     * Hook invoked after a run has finished and the command is watching for changes.
+     * May be used to display additional relevant data to the user.
+     * Only relevant when running in watch mode.
+     */
+    readonly waitingForChanges: SyncHook<void>;
+    /**
+     * Hook invoked after executing operations and before waitingForChanges. Allows the caller
+     * to augment or modify the log entry about to be written.
+     */
+    readonly beforeLog: SyncHook<ITelemetryData, void>;
 }
 
 /**