Repository: kubernetes-sigs/kueue

Issue:
FlavorFungibility: Change the enum values to be less misleading
<!-- Please only use this template for submitting enhancement requests -->

**What would you like to be added**:

I would like to introduce new API enum value `Stop` for the fields, `whenCanPreempt` and `whenCanBorrow`. 

I like the proposal here: https://github.com/kubernetes-sigs/kueue/issues/768#issuecomment-3018818387. Since these are just enum values we don't need to wait until v1beta2.

So, we can have `Stop` instead of `Preempt` and `Borrow`:
```
whenCanPteempt: Stop / TryNextFlavor
whenCanBorrow: Stop / TryNextFlavor
```
I would like to also deprecate the old enum values in v1beta1, so that we can consider removal in v1beta2, and adjust the documentation to use new enum values.

Instead of "Stop" we can consider alternatives, maybe `StopAndChooseBestFlavor` ?

**Why is this needed**:

The current enum values are misleading. For example 

```
whenCanPreempt: Preempt
whenCanBorrow: TryNextFlavor
```
suggests we would be preempting whenever possible, however, **this is not true**. We may get two flavors:
`(Borrow, Fit), (NoBorrow, Preempt)`. Now, we will choose flavor 1, because borrowing is implicitly preferred over pteemption by default. 

What `whenCanPreempt: Preempt` really does it is just : stop looking for more flavors once Preempting flavor is found.

**Completion requirements**:

This enhancement requires the following artifacts:

- [ ] Design doc
- [ ] API change
- [ ] Docs update

The artifacts should be linked in subsequent comments.


Hints from issue comments:
@mimowo: cc @tenzen-y @pajakd @gabesaba @tenzen-y: What about supporting both `Preempt` and `Stop` during v1beta1 and marking `Preempt` as deprecated?
When we graduate the API to v1beta2, we can remove `Preempt`.
@mimowo: > What about supporting both Preempt and Stop during v1beta1 and marking Preempt as deprecated?

Yes, this is consistent with my proposal actually here: "I would like to also deprecate the old enum values in v1beta1, so that we can consider removal in v1beta2, and adjust the documentation to use new enum values.".@tenzen-y: > > What about supporting both Preempt and Stop during v1beta1 and marking Preempt as deprecated?
> 
> Yes, this is consistent with my proposal actually here: "I would like to also deprecate the old enum values in v1beta1, so that we can consider removal in v1beta2, and adjust the documentation to use new enum values.".

Awesome, lgtm. Regarding the new mode name, let me reconsider it after 0.13 release.
@olekzabl: In my feeling, for a config like

```
whenCanPreempt: Stop
whenCanBorrow: TryNextFlavor
```

it may be still quite unclear (to a user) how the clash between `Stop` and `TryNextFlavor` is resolved.
I mean, given a flavor with `(Borrow, Preempt)` - do we stop, or do we try next flavor?

My understanding of the code is that `TryNextFlavor` always wins over `Stop` (currently still named `Borrow` / `Preempt`).
However, these names - at least in my feeling - suggest _otherwise_.
("Stop" feels more imperative, more definite, or so. It feels like the winner. It feels like "stop no matter what").

I'm thinking if we could somehow _weaken_ the `Stop` (or _strengthen_ the `TryNextFlavor`) to make this clearer. For example:

* `StopIfFeasible` / `TryNextFlavor`
* `FineToStop` / `TryNextFlavor`
* `Stop` / `ForceTryNext`

What would you say? @pajakd @mimowo @tenzen-y @ganczak-commits: To me, `Stop` was confusing. I now understand it means "Stop the loop of looking for an adequate flavor" - but it took me a while to figure this out, my first thought was "is it stop as in 'stop the job instead of preempting (killing) it'?".

I'd vote for the combination `UseIfFeasible`/`TryNextFlavor`@mimowo: > it may be still quite unclear (to a user) how the clash between Stop and TryNextFlavor is resolved.

Good point!

> I'm thinking if we could somehow weaken the Stop (or strengthen the TryNextFlavor) to make this clearer. 

I agree with this direction.

> StopIfFeasible / TryNextFlavor
> FineToStop / TryNextFlavor

Sound ok-ish, but maybe `Fine` is too informal, also "Feasible" suggests there are more checks to be done.

What about `ReadyToStop` / `TryNextFlavor` .

Then `whenCanBorrow: ReadyToStop` + `whenCanPreempt: TryNextFlavor` reads naturally, wdyt?



@olekzabl: > Then `whenCanBorrow: ReadyToStop` + `whenCanPreempt: TryNextFlavor` reads naturally, wdyt?

I like it - though I'd like it even more if we follow the comment from @ganczak-commits and replace `Stop` with `Use`.@mimowo: As much as I like short names, wouldnt Use suffer from the same as Stop?

I mean that it sounds defnitive, and thus is confusing because:
1. it suggests the flavor is going to be used but in fact we select the best from the set
2. it conflicts semantically with TryNextFlavor , because the algo currently moves forward and tries next.

Maybe 'ReadyToStopAndUseBestFlavor' to make the name more self explanatory.@olekzabl: Oh, apologies for not being clear.
What I meant is to replace `Stop` with `Use` _on top of_ your proposal.

That is: `whenCanBorrow: ReadyToUse` + `whenCanPreempt: TryNextFlavor`.@mimowo: Got it, `whenCanBorrow: ReadyToUse + whenCanPreempt: TryNextFlavor` sounds great to me. 

wdyt @pajakd @tenzen-y ? If no objections I will just look forward for the PR@ganczak-commits: /assign@amy: @ganczak-commits @mimowo To clarify...

ReadyToUse/Preempt/Borrow means... stick to the current flavor if you can fit with preemption/borrowing.
TryNextFlavor means... if your workload doesn't fit squarely within the flavor without preemption/borrowing, pick the next flavor.

Right? @mimowo: Not exactly. The FlavorFungability has two phases:
1. determine the set of flavors, starting from one (TryNextFlavor expands the set, while two "ReadyToUse" close the set)
2. choose the "best" flavor within the set

Thus, the "Preempt" or "Borrow" where misleading, because even if a flavor says "Preempt" then the second phase may choose a flavor which is "Borrowing" as "best" (and vice versa). It is the new feature gate FlavorFungibilityImplicitPreferenceDefault which determines the "best" selection logic in the second phase.

cc @pajakd to keep me honest here.@pajakd: The original enums are misleading for many reasons. For example if `whenCanPreempt=Preempt`, `whenCanBorrow=TryNextFlavor` and we find a perfect flavor that has `(Fit,NoBorrow)` then we obviously pick it and we don't preempt (because we don't need to).

In general this API is a little bit outdated since for instance borrowing is no longer binary (and there are cases where every CQ is borrowing from some cohort). So, we have to move towards the API that can express these two-phases (restrict flavors to choose + preference) in an intuitive way. And this rename is a good step towards this.


@amy: Okay let me... repeat what y'all are saying:

Part 1: 
So when running through the list of flavors...
- `TryNextFlavor`: will construct a set of all flavors where the workload fits (or requires borrow/preemption to fit)
- Preempt/Borrow (replaced by ReadToUse): will stop at the first flavor you find that the workload fits (or requires preemption/borrow to fit)

Part 2:
FlavorFungibilityImplicitPreferenceDefault=true/false then picks out of the set of flavors you constructed above?

Solution patch:
diff --git a/.dockerignore b/.dockerignore
index 763018aa6..da1ec29db 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -19,7 +19,7 @@ examples
 bin
 artifacts
 testbin/*
-.DS_Store
+**/.DS_Store
 go.work*
 # Test binary, build with `go test -c`
 *.test
@@ -34,9 +34,9 @@ build_logs
 .idea
 .vscode
 *.nix
-*.swp
-*.swo
-*~
+**/*.swp
+**/*.swo
+**/*~
 
 # Local Netlify folder
 .netlify
@@ -45,4 +45,4 @@ build_logs
 dep-crds
 
 kueue.yaml
-node_modules
+**/node_modules
diff --git a/apis/kueue/v1beta1/clusterqueue_types.go b/apis/kueue/v1beta1/clusterqueue_types.go
index 82823f9e4..8a5e9975b 100644
--- a/apis/kueue/v1beta1/clusterqueue_types.go
+++ b/apis/kueue/v1beta1/clusterqueue_types.go
@@ -385,6 +385,7 @@ type FlavorFungibilityPolicy string
 const (
 	Borrow        FlavorFungibilityPolicy = "Borrow"
 	Preempt       FlavorFungibilityPolicy = "Preempt"
+	MayStopSearch FlavorFungibilityPolicy = "MayStopSearch"
 	TryNextFlavor FlavorFungibilityPolicy = "TryNextFlavor"
 )
 
@@ -394,22 +395,24 @@ type FlavorFungibility struct {
 	// whenCanBorrow determines whether a workload should try the next flavor
 	// before borrowing in current flavor. The possible values are:
 	//
-	// - `Borrow` (default): allocate in current flavor if borrowing
-	//   is possible.
-	// - `TryNextFlavor`: try next flavor even if the current
-	//   flavor has enough resources to borrow.
+	// - `MayStopSearch` (default): stop the search for candidate flavors if workload
+	//   fits or requires borrowing to fit.
+	// - `TryNextFlavor`: try next flavor if workload requires borrowing to fit.
+	// - `Borrow` (deprecated): old name for `MayStopSearch`; please use new name.
 	//
-	// +kubebuilder:validation:Enum={Borrow,TryNextFlavor}
-	// +kubebuilder:default="Borrow"
+	// +kubebuilder:validation:Enum={MayStopSearch,TryNextFlavor,Borrow}
+	// +kubebuilder:default="MayStopSearch"
 	WhenCanBorrow FlavorFungibilityPolicy `json:"whenCanBorrow,omitempty"`
 	// whenCanPreempt determines whether a workload should try the next flavor
 	// before borrowing in current flavor. The possible values are:
 	//
-	// - `Preempt`: allocate in current flavor if it's possible to preempt some workloads.
-	// - `TryNextFlavor` (default): try next flavor even if there are enough
-	//   candidates for preemption in the current flavor.
+	// - `MayStopSearch`: stop the search for candidate flavors if workload fits or requires
+	//   preemption to fit.
+	// - `TryNextFlavor` (default): try next flavor if workload requires preemption
+	//   to fit in current flavor.
+	// - `Preempt` (deprecated): old name for `MayStopSearch`; please use new name.
 	//
-	// +kubebuilder:validation:Enum={Preempt,TryNextFlavor}
+	// +kubebuilder:validation:Enum={MayStopSearch,TryNextFlavor,Preempt}
 	// +kubebuilder:default="TryNextFlavor"
 	WhenCanPreempt FlavorFungibilityPolicy `json:"whenCanPreempt,omitempty"`
 }
diff --git a/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml b/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml
index 890b7624c..45a63149f 100644
--- a/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml
+++ b/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml
@@ -177,18 +177,19 @@ spec:
                     before borrowing or preempting in the flavor being evaluated.
                   properties:
                     whenCanBorrow:
-                      default: Borrow
+                      default: MayStopSearch
                       description: |-
                         whenCanBorrow determines whether a workload should try the next flavor
                         before borrowing in current flavor. The possible values are:
 
-                        - `Borrow` (default): allocate in current flavor if borrowing
-                          is possible.
-                        - `TryNextFlavor`: try next flavor even if the current
-                          flavor has enough resources to borrow.
+                        - `MayStopSearch` (default): stop the search for candidate flavors if workload
+                          fits or requires borrowing to fit.
+                        - `TryNextFlavor`: try next flavor if workload requires borrowing to fit.
+                        - `Borrow` (deprecated): old name for `MayStopSearch`; please use new name.
                       enum:
-                        - Borrow
+                        - MayStopSearch
                         - TryNextFlavor
+                        - Borrow
                       type: string
                     whenCanPreempt:
                       default: TryNextFlavor
@@ -196,12 +197,15 @@ spec:
                         whenCanPreempt determines whether a workload should try the next flavor
                         before borrowing in current flavor. The possible values are:
 
-                        - `Preempt`: allocate in current flavor if it's possible to preempt some workloads.
-                        - `TryNextFlavor` (default): try next flavor even if there are enough
-                          candidates for preemption in the current flavor.
+                        - `MayStopSearch`: stop the search for candidate flavors if workload fits or requires
+                          preemption to fit.
+                        - `TryNextFlavor` (default): try next flavor if workload requires preemption
+                          to fit in current flavor.
+                        - `Preempt` (deprecated): old name for `MayStopSearch`; please use new name.
                       enum:
-                        - Preempt
+                        - MayStopSearch
                         - TryNextFlavor
+                        - Preempt
                       type: string
                   type: object
                 namespaceSelector:
diff --git a/cmd/kueueviz/examples/01-cluster-queues.yaml b/cmd/kueueviz/examples/01-cluster-queues.yaml
index 51830e92e..59b35a612 100644
--- a/cmd/kueueviz/examples/01-cluster-queues.yaml
+++ b/cmd/kueueviz/examples/01-cluster-queues.yaml
@@ -12,8 +12,8 @@ spec:
     withinClusterQueue: LowerPriority
     reclaimWithinCohort: Any # if the pending Workload fits within the nominal quota of its ClusterQueue, preempt any Workload in the cohort, irrespective of priority.
   flavorFungibility:
-    whenCanBorrow: Borrow  # this is the default but I'm making it explicit here
-    whenCanPreempt: Preempt  # ensures that accelerators aren't hit with compute workloads
+    whenCanBorrow: MayStopSearch  # this is the default but I'm making it explicit here
+    whenCanPreempt: MayStopSearch  # ensures that accelerators aren't hit with compute workloads
   resourceGroups:
   - coveredResources: ["cpu", "memory"]
     flavors:
@@ -40,8 +40,8 @@ spec:
   preemption:
     reclaimWithinCohort: Never # do not preempt Workloads in the cohort. 
   flavorFungibility:
-    whenCanBorrow: Borrow  # this is the default but I'm making it explicit here
-    whenCanPreempt: Preempt  # ensures that accelerators aren't hit with compute workloads
+    whenCanBorrow: MayStopSearch  # this is the default but I'm making it explicit here
+    whenCanPreempt: MayStopSearch  # ensures that accelerators aren't hit with compute workloads
   resourceGroups:
   - coveredResources: ["cpu", "memory"]
     flavors:
@@ -63,8 +63,8 @@ spec:
   preemption:
     reclaimWithinCohort: LowerPriority # only preempt Workloads in the cohort that have lower priority than the pending Workload.
   flavorFungibility:
-    whenCanBorrow: Borrow  # this is the default but I'm making it explicit here
-    whenCanPreempt: Preempt  # ensures that accelerators aren't hit with compute workloads
+    whenCanBorrow: MayStopSearch  # this is the default but I'm making it explicit here
+    whenCanPreempt: MayStopSearch  # ensures that accelerators aren't hit with compute workloads
   resourceGroups:
   - coveredResources: ["cpu", "memory"]
     flavors:
diff --git a/cmd/kueueviz/frontend/src/ClusterQueueDetail.jsx b/cmd/kueueviz/frontend/src/ClusterQueueDetail.jsx
index 0a95960c0..085983eb3 100644
--- a/cmd/kueueviz/frontend/src/ClusterQueueDetail.jsx
+++ b/cmd/kueueviz/frontend/src/ClusterQueueDetail.jsx
@@ -69,12 +69,12 @@ const ClusterQueueDetail = () => {
       </Typography>
       <Grid container spacing={2}>
         <Grid item xs={12} sm={6}>
-          <Tooltip title="Determines whether to try the next flavor if a workload can borrow in the current one. Possible values: Borrow, TryNextFlavor.">
-            <Typography variant="body1"><strong>When Can Borrow:</strong> {clusterQueue.spec?.flavorFungibility?.whenCanBorrow || 'Default (Borrow)'}</Typography>
+          <Tooltip title="Determines whether to try the next flavor if a workload can borrow in the current one. Possible values: MayStopSearch, TryNextFlavor, Borrow.">
+            <Typography variant="body1"><strong>When Can Borrow:</strong> {clusterQueue.spec?.flavorFungibility?.whenCanBorrow || 'Default (MayStopSearch)'}</Typography>
           </Tooltip>
         </Grid>
         <Grid item xs={12} sm={6}>
-          <Tooltip title="Determines whether to try the next flavor if preemption fails in the current one. Possible values: Preempt, TryNextFlavor.">
+          <Tooltip title="Determines whether to try the next flavor if preemption fails in the current one. Possible values: MayStopSearch, TryNextFlavor, Preempt.">
             <Typography variant="body1"><strong>When Can Preempt:</strong> {clusterQueue.spec?.flavorFungibility?.whenCanPreempt || 'Default (TryNextFlavor)'}</Typography>
           </Tooltip>
         </Grid>
diff --git a/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml b/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml
index 12a3a1e75..eb24cf4e3 100644
--- a/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml
+++ b/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml
@@ -164,18 +164,19 @@ spec:
                   before borrowing or preempting in the flavor being evaluated.
                 properties:
                   whenCanBorrow:
-                    default: Borrow
+                    default: MayStopSearch
                     description: |-
                       whenCanBorrow determines whether a workload should try the next flavor
                       before borrowing in current flavor. The possible values are:
 
-                      - `Borrow` (default): allocate in current flavor if borrowing
-                        is possible.
-                      - `TryNextFlavor`: try next flavor even if the current
-                        flavor has enough resources to borrow.
+                      - `MayStopSearch` (default): stop the search for candidate flavors if workload
+                        fits or requires borrowing to fit.
+                      - `TryNextFlavor`: try next flavor if workload requires borrowing to fit.
+                      - `Borrow` (deprecated): old name for `MayStopSearch`; please use new name.
                     enum:
-                    - Borrow
+                    - MayStopSearch
                     - TryNextFlavor
+                    - Borrow
                     type: string
                   whenCanPreempt:
                     default: TryNextFlavor
@@ -183,12 +184,15 @@ spec:
                       whenCanPreempt determines whether a workload should try the next flavor
                       before borrowing in current flavor. The possible values are:
 
-                      - `Preempt`: allocate in current flavor if it's possible to preempt some workloads.
-                      - `TryNextFlavor` (default): try next flavor even if there are enough
-                        candidates for preemption in the current flavor.
+                      - `MayStopSearch`: stop the search for candidate flavors if workload fits or requires
+                        preemption to fit.
+                      - `TryNextFlavor` (default): try next flavor if workload requires preemption
+                        to fit in current flavor.
+                      - `Preempt` (deprecated): old name for `MayStopSearch`; please use new name.
                     enum:
-                    - Preempt
+                    - MayStopSearch
                     - TryNextFlavor
+                    - Preempt
                     type: string
                 type: object
               namespaceSelector:
diff --git a/keps/582-preempt-based-on-flavor-order/README.md b/keps/582-preempt-based-on-flavor-order/README.md
index 153cca91d..eb094325a 100644
--- a/keps/582-preempt-based-on-flavor-order/README.md
+++ b/keps/582-preempt-based-on-flavor-order/README.md
@@ -123,13 +123,13 @@ in my cluster. In this case I prefer my high priority jobs not running on spot
 instances. If high priority jobs can preempt jobs in standard instances before trying spot instances,
 stability can be achieved.
 
-My use case can be supported by setting `.Spec.FlavorFungibility.WhenCanPreempt` to `Preempt` in the ClusterQueue's spec.
+My use case can be supported by setting `.Spec.FlavorFungibility.WhenCanPreempt` to `MayStopSearch` in the ClusterQueue's spec.
 
 #### Story 2
 
 As an admin of system managed by Kueue I would like to minimize the risk that admitted workloads get preempted soon after admission. Since every borrowing workload is a preemption (reclaim) candidate, to minimize the risk, I would like to prioritize selecting flavors which are preempting rather than borrowing.
 
-My use case can be supported by setting `Spec.FlavorFungibility.WhenCanPreempt: Preempt`.
+My use case can be supported by setting `Spec.FlavorFungibility.WhenCanPreempt: MayStopSearch`.
 
 ### Notes/Constraints/Caveats (Optional)
 
@@ -171,33 +171,35 @@ For each type of resource in each podSet, Kueue will traverse all resource group
 
 ```
 const (
-  Borrow FlavorFungibilityPolicy = "Borrow"
-  Preempt  FlavorFungibilityPolicy = "Preempt"
-  TryNextFlavor FlavorFungibilityPolicy = "TryNextFlavor"
+	Borrow        FlavorFungibilityPolicy = "Borrow"
+	Preempt       FlavorFungibilityPolicy = "Preempt"
+	MayStopSearch FlavorFungibilityPolicy = "MayStopSearch"
+	TryNextFlavor FlavorFungibilityPolicy = "TryNextFlavor"
 )
 
 type FlavorFungibility struct {
   // whenCanBorrow determines whether a workload should try the next flavor
   // or stop the search. The possible values are:
   //
-  // - `Borrow` (default): stop searching and use the best flavor found so far
-  //   according to the selection strategy
-  // - `TryNextFlavor`: try next flavor even if the current
-  //   flavor has enough resources to borrow.
+	// - `MayStopSearch` (default): stop the search for candidate flavors if workload
+	//   fits or requires borrowing to fit.
+	// - `TryNextFlavor`: try next flavor if workload requires borrowing to fit.
+	// - `Borrow` (deprecated): old name for `MayStopSearch`; please use new name.
   //
-  // +kubebuilder:validation:Enum={Borrow,TryNextFlavor}
-  // +kubebuilder:default="Borrow"
+	// +kubebuilder:validation:Enum={MayStopSearch,TryNextFlavor,Borrow}
+	// +kubebuilder:default="MayStopSearch"
   WhenCanBorrow FlavorFungibilityPolicy  `json:"whenCanBorrow"`
   // whenCanPreempt determines whether a workload should try the next flavor
   // or stop the search. The possible values are:
   //
-  // - `Preempt`: stop searching and use the best flavor found so far 
-  //   according to the selection strategy
-  // - `TryNextFlavor` (default): try next flavor even if there are enough
-  //   candidates for preemption in the current flavor.
+	// - `MayStopSearch`: stop the search for candidate flavors if workload fits or requires
+	//   preemption to fit.
+	// - `TryNextFlavor` (default): try next flavor if workload requires preemption
+	//   to fit in current flavor.
+	// - `Preempt` (deprecated): old name for `MayStopSearch`; please use new name.
   //
-  // +kubebuilder:validation:Enum={Preempt,TryNextFlavor}
-  // +kubebuilder:default="TryNextFlavor"
+	// +kubebuilder:validation:Enum={MayStopSearch,TryNextFlavor,Preempt}
+	// +kubebuilder:default="TryNextFlavor"
   WhenCanPreempt FlavorFungibilityPolicy `json:"whenCanPreempt"`
 }
 
@@ -208,7 +210,7 @@ type ClusterQueueSpec struct {
 }
 ```
 
-If flavorFungibility is nil in configuration, we will set the `WhenCanBorrow` to `Borrow` and set `WhenCanPreempt` to `TryNextFlavor` to maintain consistency with the current behavior.
+If flavorFungibility is nil in configuration, we will set the `WhenCanBorrow` to `MayStopSearch` and set `WhenCanPreempt` to `TryNextFlavor` to maintain consistency with the current behavior.
 
 ### Behavior Changes
 
@@ -220,9 +222,9 @@ We try to schedule a podset in succesive resource flavors in a loop and we decid
 |------ | -------- | ------- |
 | `NoFit` | any | continue |
 | `Preempt`, `NoBorrow` | `WhenCanPreempt = TryNextFlavor` | continue |
-| `Preempt`, `NoBorrow` | `WhenCanPreempt = Preempt` | break |
+| `Preempt`, `NoBorrow` | `WhenCanPreempt = MayStopSearch` | break |
 | `Fit`, `Borrow` | `WhenCanBorrow = TryNextFlavor` | continue |
-| `Fit`, `Borrow` | `WhenCanBorrow = Borrow` | break |
+| `Fit`, `Borrow` | `WhenCanBorrow = MayStopSearch` | break |
 | `Fit`, `NoBorrow`| any| break| 
 
 By `Borrow`/`NoBorrow` we mean whether borrowing is required or not to fit the considered podset in the sumulation result. After we complete the loop, either by trying all the flavors or by breaking out of it, we end up with a list of possible flavors containing all the considered flavors that yielded a result different than `NoFit`. We choose the flavor to assign based on the following default preference order: (`Fit`, `NoBorrow`), (`Fit`, `Borrow`), (`Preempt`, `NoBorrow`), (`Preempt`, `Borrow`).
@@ -230,7 +232,7 @@ By `Borrow`/`NoBorrow` we mean whether borrowing is required or not to fit the c
 An alternative order of preference can be set by enabling the feature gate `FlavorFungibilityImplicitPreferenceDefault`.
 The alternative order prioritizes assignments that don't borrow: (`Fit`, `NoBorrow`),(`Preempt`, `NoBorrow`), (`Fit`, `Borrow`), (`Preempt`, `Borrow`). It is used in two cases:
 
-1. If `WhenCanPreempt = Preempt` and `WhenCanBorrow = TryNextFlavor`
+1. If `WhenCanPreempt = MayStopSearch` and `WhenCanBorrow = TryNextFlavor`
 2. If `WhenCanPreempt = TryNextFlavor` and `WhenCanBorrow = TryNextFlavor`
 
 We will store the scheduling context in workload info so that we can start from where we stop in previous scheduling attempts. This will be useful to avoid to waste time in one flavor all the time if we try to preempt in a flavor and failed. Scheduling context will contain the `LastTriedFlavorIdx`, `ClusterQueueGeneration` attached to the CQ and `CohortGeneration`. Any changes to these properties will lead to a scheduling from the first flavor.
@@ -385,10 +387,10 @@ Describe what tests will be added to ensure proper quality of the enhancement.
 
 After the implementation PR is merged, add the names of the tests here.
 -->
-Scenarios that `WhenCanBorrow` is set as `Borrow` and `WhenCanPreempt` is set as `tryNextFlavor` are same with current behavior. So the added integration tests will these cover scenarios:
+Scenarios that `WhenCanBorrow` is set as `MayStopSearch` and `WhenCanPreempt` is set as `TryNextFlavor` are same with current behavior. So the added integration tests will these cover scenarios:
 
-- `WhenCanBorrow` is set as `tryNextFlavor`,
-- `WhenCanPreempt` is set as `Preempt`.
+- `WhenCanBorrow` is set as `TryNextFlavor`,
+- `WhenCanPreempt` is set as `MayStopSearch`.
 
 ### Graduation Criteria
 
diff --git a/pkg/cache/scheduler/clusterqueue.go b/pkg/cache/scheduler/clusterqueue.go
index 5d11139ce..93587c72b 100644
--- a/pkg/cache/scheduler/clusterqueue.go
+++ b/pkg/cache/scheduler/clusterqueue.go
@@ -114,7 +114,7 @@ var defaultPreemption = kueue.ClusterQueuePreemption{
 	WithinClusterQueue:  kueue.PreemptionPolicyNever,
 }
 
-var defaultFlavorFungibility = kueue.FlavorFungibility{WhenCanBorrow: kueue.Borrow, WhenCanPreempt: kueue.TryNextFlavor}
+var defaultFlavorFungibility = kueue.FlavorFungibility{WhenCanBorrow: kueue.MayStopSearch, WhenCanPreempt: kueue.TryNextFlavor}
 
 func (c *clusterQueue) updateClusterQueue(log logr.Logger, in *kueue.ClusterQueue, resourceFlavors map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor, admissionChecks map[kueue.AdmissionCheckReference]AdmissionCheck, oldParent *cohort) error {
 	if c.updateQuotasAndResourceGroups(in.Spec.ResourceGroups) || oldParent != c.Parent() {
diff --git a/site/content/en/docs/concepts/cluster_queue.md b/site/content/en/docs/concepts/cluster_queue.md
index 75360301a..10500e051 100644
--- a/site/content/en/docs/concepts/cluster_queue.md
+++ b/site/content/en/docs/concepts/cluster_queue.md
@@ -494,19 +494,21 @@ metadata:
 spec:
   flavorFungibility:
     whenCanBorrow: TryNextFlavor
-    whenCanPreempt: Preempt
+    whenCanPreempt: MayStopSearch
 ```
 
 The fields above do the following:
 
 - `whenCanBorrow` defines what should happen if a workload can get enough resource by
 borrowing in current ResourceFlavor. The possible values are:
-  - `Borrow` (default): Kueue stops looking for a better assignment.
+  - `MayStopSearch` (default): Kueue stops looking for a better assignment.
   - `TryNextFlavor`: Kueue tries the next ResourceFlavor.
+  - `Borrow` (deprecated): Old name for `MayStopSearch`.
 - `whenCanPreempt` defines what should happen if a workload can get enough resource by
 preempting in current ResourceFlavor. The possible values are:
-  - `Preempt`: Kueue stops looking for a better assignment.
+  - `MayStopSearch`: Kueue stops looking for a better assignment.
   - `TryNextFlavor` (default): Kueue tries the next ResourceFlavor.
+  - `Preempt` (deprecated): Old name for `MayStopSearch`.
 
 If during the search, Kueue finds some ResourceFlavor in which it can fit
 without preemption or borrowing, such ResourceFlavor is immediately selected,
diff --git a/site/content/en/docs/reference/kueue.v1beta1.md b/site/content/en/docs/reference/kueue.v1beta1.md
index bfba8f42c..0fff02f80 100644
--- a/site/content/en/docs/reference/kueue.v1beta1.md
+++ b/site/content/en/docs/reference/kueue.v1beta1.md
@@ -1449,10 +1449,10 @@ before borrowing or preempting in current flavor.</p>
    <p>whenCanBorrow determines whether a workload should try the next flavor
 before borrowing in current flavor. The possible values are:</p>
 <ul>
-<li><code>Borrow</code> (default): allocate in current flavor if borrowing
-is possible.</li>
-<li><code>TryNextFlavor</code>: try next flavor even if the current
-flavor has enough resources to borrow.</li>
+<li><code>MayStopSearch</code> (default): stop the search for candidate flavors if workload
+fits or requires borrowing to fit.</li>
+<li><code>TryNextFlavor</code>: try next flavor if workload requires borrowing to fit.</li>
+<li><code>Borrow</code> (deprecated): old name for <code>MayStopSearch</code>; please use new name.</li>
 </ul>
 </td>
 </tr>
@@ -1463,9 +1463,11 @@ flavor has enough resources to borrow.</li>
    <p>whenCanPreempt determines whether a workload should try the next flavor
 before borrowing in current flavor. The possible values are:</p>
 <ul>
-<li><code>Preempt</code>: allocate in current flavor if it's possible to preempt some workloads.</li>
-<li><code>TryNextFlavor</code> (default): try next flavor even if there are enough
-candidates for preemption in the current flavor.</li>
+<li><code>MayStopSearch</code>: stop the search for candidate flavors if workload fits or requires
+preemption to fit.</li>
+<li><code>TryNextFlavor</code> (default): try next flavor if workload requires preemption
+to fit in current flavor.</li>
+<li><code>Preempt</code> (deprecated): old name for <code>MayStopSearch</code>; please use new name.</li>
 </ul>
 </td>
 </tr>
diff --git a/site/content/en/docs/tasks/run/deployment.md b/site/content/en/docs/tasks/run/deployment.md
index 2552ca906..61cd8edcd 100644
--- a/site/content/en/docs/tasks/run/deployment.md
+++ b/site/content/en/docs/tasks/run/deployment.md
@@ -23,8 +23,21 @@ For more information, see [Kueue's overview](/docs/overview).
 
 1. Learn how to [install Kueue with a custom manager configuration](/docs/installation/#install-a-custom-configured-released-version).
 
-2. Follow steps in [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin)
-to learn how to enable and configure the `pod` integration.
+2. Ensure that you have the `deployment` integration enabled, for example:
+   ```yaml
+   apiVersion: config.kueue.x-k8s.io/v1beta1
+   kind: Configuration
+   integrations:
+     frameworks:
+      - "deployment"
+   ```
+   {{% alert title="Pod integration requirements" color="primary" %}}
+   Since Kueue v0.15, you don't need to explicitly enable `"pod"` integration to use the `"deployment"` integration.
+
+   For Kueue v0.14 and earlier, `"pod"` integration must be explicitly enabled.
+
+   See [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin) for configuration details.
+   {{% /alert %}}
 
 3. Check [Administer cluster quotas](/docs/tasks/manage/administer_cluster_quotas) for details on the initial Kueue setup.
 
diff --git a/site/content/en/docs/tasks/run/leaderworkerset.md b/site/content/en/docs/tasks/run/leaderworkerset.md
index 4cb1d74ba..193e2d999 100644
--- a/site/content/en/docs/tasks/run/leaderworkerset.md
+++ b/site/content/en/docs/tasks/run/leaderworkerset.md
@@ -29,11 +29,15 @@ For more information, see [Kueue's overview](/docs/overview).
    kind: Configuration
    integrations:
      frameworks:
-      - "pod"
       - "leaderworkerset.x-k8s.io/leaderworkerset"
    ```
-   Also, follow steps in [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin)
-   to learn how to enable and configure the `pod` integration.
+   {{% alert title="Pod integration requirements" color="primary" %}}
+   Since Kueue v0.15, you don't need to explicitly enable `"pod"` integration to use the `"leaderworkerset.x-k8s.io/leaderworkerset"` integration.
+
+   For Kueue v0.14 and earlier, `"pod"` integration must be explicitly enabled.
+
+   See [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin) for configuration details.
+   {{% /alert %}}
 
 3. Check [Administer cluster quotas](/docs/tasks/manage/administer_cluster_quotas) for details on the initial Kueue setup.
 
diff --git a/site/content/en/docs/tasks/run/multikueue/deployment.md b/site/content/en/docs/tasks/run/multikueue/deployment.md
index c3a166359..a48cfc091 100644
--- a/site/content/en/docs/tasks/run/multikueue/deployment.md
+++ b/site/content/en/docs/tasks/run/multikueue/deployment.md
@@ -11,10 +11,15 @@ description: >
 
 1. Check the [MultiKueue installation guide](/docs/tasks/manage/setup_multikueue) on how to properly setup MultiKueue clusters.
 
-2. Follow steps in [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin)
-to learn how to enable and configure the `pod` integration which is required for enabling the `deployment` integration.
+2. Deployments receive live status updates through the status from the remote Pods created on the worker cluster.
 
-Deployments receive live status updates through the status from the remote Pods created on the worker cluster.
+   {{% alert title="Pod integration requirements" color="primary" %}}
+   Since Kueue v0.15, you don't need to explicitly enable `"pod"` integration to use the `"deployment"` integration.
+
+   For Kueue v0.14 and earlier, `"pod"` integration must be explicitly enabled.
+
+   See [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin) for configuration details.
+   {{% /alert %}}
 
 {{< feature-state state="beta" for_version="v0.11.0" >}}
 
diff --git a/site/content/en/docs/tasks/run/statefulset.md b/site/content/en/docs/tasks/run/statefulset.md
index 7261469a9..48cc78e5e 100644
--- a/site/content/en/docs/tasks/run/statefulset.md
+++ b/site/content/en/docs/tasks/run/statefulset.md
@@ -27,11 +27,15 @@ For more information, see [Kueue's overview](/docs/overview).
    kind: Configuration
    integrations:
      frameworks:
-      - "pod" # required by statefulset
       - "statefulset"
    ```
-   Also, follow steps in [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin)
-   to learn how to enable and configure the `pod` integration.
+   {{% alert title="Pod integration requirements" color="primary" %}}
+   Since Kueue v0.15, you don't need to explicitly enable `"pod"` integration to use the `"statefulset"` integration.
+
+   For Kueue v0.14 and earlier, `"pod"` integration must be explicitly enabled.
+
+   See [Run Plain Pods](/docs/tasks/run/plain_pods/#before-you-begin) for configuration details.
+   {{% /alert %}}
 
 3. Check [Administer cluster quotas](/docs/tasks/manage/administer_cluster_quotas) for details on the initial Kueue setup.
 
diff --git a/site/content/zh-CN/docs/concepts/cluster_queue.md b/site/content/zh-CN/docs/concepts/cluster_queue.md
index 31bb031e5..c12438a34 100644
--- a/site/content/zh-CN/docs/concepts/cluster_queue.md
+++ b/site/content/zh-CN/docs/concepts/cluster_queue.md
@@ -458,17 +458,19 @@ metadata:
 spec:
   flavorFungibility:
     whenCanBorrow: TryNextFlavor
-    whenCanPreempt: Preempt
+    whenCanPreempt: MayStopSearch
 ```
 
 上述字段如下：
 
 - `whenCanBorrow` 确定是否应该停止寻找更好的分配，如果工作负载可以通过借用当前 ResourceFlavor 获得足够的资源。可能的值是：
-  - `Borrow`（默认）：ClusterQueue 停止寻找更好的分配。
+  - `MayStopSearch`（默认）：ClusterQueue 停止寻找更好的分配。
   - `TryNextFlavor`：ClusterQueue 尝试下一个 ResourceFlavor 以查看工作负载是否可以获得更好的分配。
+  - `Borrow`（已弃用）。
 - `whenCanPreempt` 确定是否应该尝试预留当前 ResourceFlavor 中的工作负载，然后再尝试下一个。可能的值是：
-  - `Preempt`：ClusterQueue 停止尝试预留当前 ResourceFlavor 并从下一个开始，如果预留失败。
+  - `MayStopSearch`：ClusterQueue 停止尝试预留当前 ResourceFlavor 并从下一个开始，如果预留失败。
   - `TryNextFlavor`（默认）：ClusterQueue 尝试下一个 ResourceFlavor 以查看工作负载是否适合 ResourceFlavor。
+  - `Preempt`（已弃用）。
 
 默认情况下，新进入的工作负载停止尝试下一个风味，如果工作负载可以获得足够的借用资源。
 并且 Kueue 仅在 Kueue 确定剩余 ResourceFlavors 无法适应工作负载时触发预留。
diff --git a/site/content/zh-CN/docs/reference/kueue.v1beta1.md b/site/content/zh-CN/docs/reference/kueue.v1beta1.md
index ea378e67f..9082b376b 100644
--- a/site/content/zh-CN/docs/reference/kueue.v1beta1.md
+++ b/site/content/zh-CN/docs/reference/kueue.v1beta1.md
@@ -1378,10 +1378,10 @@ before borrowing or preempting in current flavor.</p>
    <p>whenCanBorrow determines whether a workload should try the next flavor
 before borrowing in current flavor. The possible values are:</p>
 <ul>
-<li><code>Borrow</code> (default): allocate in current flavor if borrowing
-is possible.</li>
-<li><code>TryNextFlavor</code>: try next flavor even if the current
-flavor has enough resources to borrow.</li>
+<li><code>MayStopSearch</code> (default): stop the search for candidate flavors if workload
+fits or requires borrowing to fit.</li>
+<li><code>TryNextFlavor</code>: try next flavor if workload requires borrowing to fit.</li>
+<li><code>Borrow</code> (deprecated): old name for <code>MayStopSearch</code>; please use new name.</li>
 </ul>
 </td>
 </tr>
@@ -1392,9 +1392,11 @@ flavor has enough resources to borrow.</li>
    <p>whenCanPreempt determines whether a workload should try the next flavor
 before borrowing in current flavor. The possible values are:</p>
 <ul>
-<li><code>Preempt</code>: allocate in current flavor if it's possible to preempt some workloads.</li>
-<li><code>TryNextFlavor</code> (default): try next flavor even if there are enough
-candidates for preemption in the current flavor.</li>
+<li><code>MayStopSearch</code>: stop the search for candidate flavors if workload fits or requires
+preemption to fit.</li>
+<li><code>TryNextFlavor</code> (default): try next flavor if workload requires preemption
+to fit in current flavor.</li>
+<li><code>Preempt</code> (deprecated): old name for <code>MayStopSearch</code>; please use new name.</li>
 </ul>
 </td>
 </tr>



Test patch:
diff --git a/pkg/cache/scheduler/clusterqueue_test.go b/pkg/cache/scheduler/clusterqueue_test.go
index 78ba59efb..1c44cf35b 100644
--- a/pkg/cache/scheduler/clusterqueue_test.go
+++ b/pkg/cache/scheduler/clusterqueue_test.go
@@ -102,7 +102,7 @@ func TestClusterQueueUpdate(t *testing.T) {
 				WithinClusterQueue: kueue.PreemptionPolicyLowerPriority,
 			}).
 			FlavorFungibility(kueue.FlavorFungibility{
-				WhenCanPreempt: kueue.Preempt,
+				WhenCanPreempt: kueue.MayStopSearch,
 			}).
 			ResourceGroup(
 				*utiltesting.MakeFlavorQuotas("on-demand").
@@ -117,7 +117,7 @@ func TestClusterQueueUpdate(t *testing.T) {
 				WithinClusterQueue: kueue.PreemptionPolicyLowerPriority,
 			}).
 			FlavorFungibility(kueue.FlavorFungibility{
-				WhenCanPreempt: kueue.Preempt,
+				WhenCanPreempt: kueue.MayStopSearch,
 			}).
 			ResourceGroup(
 				*utiltesting.MakeFlavorQuotas("on-demand").
@@ -540,7 +540,7 @@ func TestClusterQueueReadinessWithTAS(t *testing.T) {
 					WithinClusterQueue: kueue.PreemptionPolicyLowerPriority,
 				}).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Obj(),
 			wantReason:  kueue.ClusterQueueActiveReasonReady,
diff --git a/pkg/cache/scheduler/snapshot_test.go b/pkg/cache/scheduler/snapshot_test.go
index c5c0d058b..7d5fdccec 100644
--- a/pkg/cache/scheduler/snapshot_test.go
+++ b/pkg/cache/scheduler/snapshot_test.go
@@ -423,7 +423,7 @@ func TestSnapshot(t *testing.T) {
 				),
 			},
 		},
-		"lendingLimit with 2 clusterQueues and 2 flavors(whenCanBorrow: Borrow)": {
+		"lendingLimit with 2 clusterQueues and 2 flavors(whenCanBorrow: MayStopSearch)": {
 			cqs: []*kueue.ClusterQueue{
 				utiltesting.MakeClusterQueue("a").
 					Cohort("lending").
diff --git a/pkg/scheduler/flavorassigner/flavorassigner_test.go b/pkg/scheduler/flavorassigner/flavorassigner_test.go
index ddf9e1c85..926a78c2e 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner_test.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner_test.go
@@ -1401,6 +1401,48 @@ func TestAssignFlavors(t *testing.T) {
 			wantRepMode: Fit,
 		},
 		"preempt before try next flavor": {
+			wlPods: []kueue.PodSet{
+				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
+					Request(corev1.ResourceCPU, "9").
+					Obj(),
+			},
+			clusterQueue: *utiltesting.MakeClusterQueue("test-clusterqueue").
+				FlavorFungibility(kueue.FlavorFungibility{WhenCanBorrow: kueue.MayStopSearch, WhenCanPreempt: kueue.MayStopSearch}).
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourcePods, "10").
+						Resource(corev1.ResourceCPU, "10").
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						Resource(corev1.ResourcePods, "10").
+						Resource(corev1.ResourceCPU, "10").
+						Obj(),
+				).Obj(),
+			clusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: 2_000,
+			},
+			wantRepMode: Preempt,
+			wantAssignment: Assignment{
+				PodSets: []PodSetAssignment{{
+					Name: kueue.DefaultPodSetName,
+					Flavors: ResourceAssignment{
+						corev1.ResourceCPU:  {Name: "one", Mode: Preempt, TriedFlavorIdx: 0},
+						corev1.ResourcePods: {Name: "one", Mode: Fit, TriedFlavorIdx: 0},
+					},
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU:  resource.MustParse("9"),
+						corev1.ResourcePods: resource.MustParse("1"),
+					},
+					Status: *NewStatus("insufficient unused quota for cpu in flavor one, 1 more needed"),
+					Count:  1,
+				}},
+				Usage: workload.Usage{Quota: resources.FlavorResourceQuantities{
+					{Flavor: "one", Resource: "cpu"}:  9_000,
+					{Flavor: "one", Resource: "pods"}: 1,
+				}},
+			},
+		},
+		"preempt before try next flavor; using deprecated WhenCanBorrow=Borrow,WhenCanPreempt=Preempt": {
 			wlPods: []kueue.PodSet{
 				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
 					Request(corev1.ResourceCPU, "9").
@@ -1634,7 +1676,65 @@ func TestAssignFlavors(t *testing.T) {
 				}},
 			},
 		},
-		"when borrowing while preemption is needed for flavor one; WhenCanBorrow=Borrow": {
+		"when borrowing while preemption is needed for flavor one; WhenCanBorrow=MayStopSearch": {
+			wlPods: []kueue.PodSet{
+				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
+					Request(corev1.ResourceCPU, "12").
+					Obj(),
+			},
+			clusterQueue: *utiltesting.MakeClusterQueue("test-clusterqueue").
+				Preemption(kueue.ClusterQueuePreemption{
+					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
+					BorrowWithinCohort: &kueue.BorrowWithinCohort{
+						Policy: kueue.BorrowWithinCohortPolicyLowerPriority,
+					},
+				}).
+				FlavorFungibility(kueue.FlavorFungibility{
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
+				}).
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						ResourceQuotaWrapper(corev1.ResourceCPU).NominalQuota("0").BorrowingLimit("12").Append().
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).Cohort("test-cohort").Obj(),
+			secondaryClusterQueue: utiltesting.MakeClusterQueue("test-secondary-clusterqueue").
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).
+				Cohort("test-cohort").
+				Obj(),
+			secondaryClusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: 10_000,
+			},
+			simulationResult: map[resources.FlavorResource]simulationResultForFlavor{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: {preemptioncommon.Preempt, 1},
+			},
+			wantRepMode: Preempt,
+			wantAssignment: Assignment{
+				Borrowing: 1,
+				PodSets: []PodSetAssignment{{
+					Name: kueue.DefaultPodSetName,
+					Flavors: ResourceAssignment{
+						corev1.ResourceCPU: {Name: "one", Mode: Preempt, TriedFlavorIdx: 0},
+					},
+					Status: *NewStatus("insufficient unused quota for cpu in flavor one, 10 more needed"),
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU: resource.MustParse("12"),
+					},
+					Count: 1,
+				}},
+				Usage: workload.Usage{Quota: resources.FlavorResourceQuantities{
+					{Flavor: "one", Resource: corev1.ResourceCPU}: 12_000,
+				}},
+			},
+		},
+		"when borrowing while preemption is needed for flavor one; WhenCanBorrow=Borrow,WhenCanPreempt=Preempt": {
 			wlPods: []kueue.PodSet{
 				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
 					Request(corev1.ResourceCPU, "12").
@@ -1692,7 +1792,65 @@ func TestAssignFlavors(t *testing.T) {
 				}},
 			},
 		},
-		"when borrowing while preemption is needed for flavor one, no borrowingLimit; WhenCanBorrow=Borrow": {
+		"when borrowing while preemption is needed for flavor one, no borrowingLimit; WhenCanBorrow=MayStopSearch": {
+			wlPods: []kueue.PodSet{
+				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
+					Request(corev1.ResourceCPU, "12").
+					Obj(),
+			},
+			clusterQueue: *utiltesting.MakeClusterQueue("test-clusterqueue").
+				Preemption(kueue.ClusterQueuePreemption{
+					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
+					BorrowWithinCohort: &kueue.BorrowWithinCohort{
+						Policy: kueue.BorrowWithinCohortPolicyLowerPriority,
+					},
+				}).
+				FlavorFungibility(kueue.FlavorFungibility{
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
+				}).
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "0").
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).Cohort("test-cohort").Obj(),
+			secondaryClusterQueue: utiltesting.MakeClusterQueue("test-secondary-clusterqueue").
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).
+				Cohort("test-cohort").
+				Obj(),
+			secondaryClusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: 10_000,
+			},
+			simulationResult: map[resources.FlavorResource]simulationResultForFlavor{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: {preemptioncommon.Preempt, 1},
+			},
+			wantRepMode: Preempt,
+			wantAssignment: Assignment{
+				Borrowing: 1,
+				PodSets: []PodSetAssignment{{
+					Name: kueue.DefaultPodSetName,
+					Flavors: ResourceAssignment{
+						corev1.ResourceCPU: {Name: "one", Mode: Preempt, TriedFlavorIdx: 0},
+					},
+					Status: *NewStatus("insufficient unused quota for cpu in flavor one, 10 more needed"),
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU: resource.MustParse("12"),
+					},
+					Count: 1,
+				}},
+				Usage: workload.Usage{Quota: resources.FlavorResourceQuantities{
+					{Flavor: "one", Resource: corev1.ResourceCPU}: 12_000,
+				}},
+			},
+		},
+		"when borrowing while preemption is needed for flavor one, no borrowingLimit; WhenCanBorrow=Borrow,WhenCanPreempt=Preempt": {
 			wlPods: []kueue.PodSet{
 				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
 					Request(corev1.ResourceCPU, "12").
@@ -1751,6 +1909,57 @@ func TestAssignFlavors(t *testing.T) {
 			},
 		},
 		"when borrowing while preemption is needed for flavor one; WhenCanBorrow=TryNextFlavor": {
+			wlPods: []kueue.PodSet{
+				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
+					Request(corev1.ResourceCPU, "12").
+					Obj(),
+			},
+			clusterQueue: *utiltesting.MakeClusterQueue("test-clusterqueue").
+				Preemption(kueue.ClusterQueuePreemption{
+					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
+					BorrowWithinCohort: &kueue.BorrowWithinCohort{
+						Policy: kueue.BorrowWithinCohortPolicyLowerPriority,
+					},
+				}).
+				FlavorFungibility(kueue.FlavorFungibility{
+					WhenCanBorrow:  kueue.TryNextFlavor,
+					WhenCanPreempt: kueue.MayStopSearch,
+				}).
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						ResourceQuotaWrapper(corev1.ResourceCPU).NominalQuota("0").BorrowingLimit("12").Append().
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).Cohort("test-cohort").
+				Obj(),
+			secondaryClusterQueue: utiltesting.MakeClusterQueue("test-secondary-clusterqueue").
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).
+				Cohort("test-cohort").
+				Obj(),
+			wantRepMode: Fit,
+			wantAssignment: Assignment{
+				PodSets: []PodSetAssignment{{
+					Name: kueue.DefaultPodSetName,
+					Flavors: ResourceAssignment{
+						corev1.ResourceCPU: {Name: "two", Mode: Fit, TriedFlavorIdx: -1},
+					},
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU: resource.MustParse("12"),
+					},
+					Count: 1,
+				}},
+				Usage: workload.Usage{Quota: resources.FlavorResourceQuantities{
+					{Flavor: "two", Resource: corev1.ResourceCPU}: 12_000,
+				}},
+			},
+		},
+		"when borrowing while preemption is needed for flavor one; WhenCanBorrow=TryNextFlavor,WhenCanPreempt=Preempt": {
 			wlPods: []kueue.PodSet{
 				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
 					Request(corev1.ResourceCPU, "12").
@@ -1950,6 +2159,64 @@ func TestAssignFlavors(t *testing.T) {
 			},
 		},
 		"cannot preempt in cohort (oracle returns None) for the first flavor, tries the second flavor (which fits)": {
+			wlPods: []kueue.PodSet{
+				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
+					Request(corev1.ResourceCPU, "2").
+					Obj(),
+			},
+			clusterQueue: *utiltesting.MakeClusterQueue("test-clusterqueue").
+				FlavorFungibility(kueue.FlavorFungibility{WhenCanBorrow: kueue.MayStopSearch, WhenCanPreempt: kueue.MayStopSearch}).
+				Preemption(kueue.ClusterQueuePreemption{
+					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
+					BorrowWithinCohort: &kueue.BorrowWithinCohort{
+						Policy: kueue.BorrowWithinCohortPolicyLowerPriority,
+					},
+				}).
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						ResourceQuotaWrapper(corev1.ResourceCPU).NominalQuota("0").BorrowingLimit("2").Append().
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						ResourceQuotaWrapper(corev1.ResourceCPU).NominalQuota("0").BorrowingLimit("2").Append().
+						Obj(),
+				).Cohort("test-cohort").
+				Obj(),
+			secondaryClusterQueue: utiltesting.MakeClusterQueue("test-secondary-clusterqueue").
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						ResourceQuotaWrapper(corev1.ResourceCPU).NominalQuota("2").Append().
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						ResourceQuotaWrapper(corev1.ResourceCPU).NominalQuota("2").Append().
+						Obj(),
+				).
+				Cohort("test-cohort").
+				Obj(),
+			secondaryClusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: 2_000,
+			},
+			simulationResult: map[resources.FlavorResource]simulationResultForFlavor{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: {preemptioncommon.NoCandidates, 0},
+			},
+			wantRepMode: Fit,
+			wantAssignment: Assignment{
+				PodSets: []PodSetAssignment{{
+					Name: kueue.DefaultPodSetName,
+					Flavors: ResourceAssignment{
+						corev1.ResourceCPU: {Name: "two", Mode: Fit, TriedFlavorIdx: -1},
+					},
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU: resource.MustParse("2"),
+					},
+					Count: 1,
+				}},
+				Borrowing: 1,
+				Usage: workload.Usage{Quota: resources.FlavorResourceQuantities{
+					{Flavor: "two", Resource: corev1.ResourceCPU}: 2_000,
+				}},
+			},
+		},
+		"cannot preempt in cohort (oracle returns None) for the first flavor, tries the second flavor (which fits); using deprecated WhenCanBorrow=Borrow,WhenCanPreempt=Preempt": {
 			wlPods: []kueue.PodSet{
 				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
 					Request(corev1.ResourceCPU, "2").
@@ -2058,6 +2325,57 @@ func TestAssignFlavors(t *testing.T) {
 			},
 		},
 		"when borrowing while preemption is needed for flavor one, fair sharing enabled, reclaimWithinCohort=Any": {
+			enableFairSharing: true,
+			wlPods: []kueue.PodSet{
+				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
+					Request(corev1.ResourceCPU, "12").
+					Obj(),
+			},
+			clusterQueue: *utiltesting.MakeClusterQueue("test-clusterqueue").
+				Preemption(kueue.ClusterQueuePreemption{ReclaimWithinCohort: kueue.PreemptionPolicyAny}).
+				FlavorFungibility(kueue.FlavorFungibility{WhenCanBorrow: kueue.MayStopSearch, WhenCanPreempt: kueue.MayStopSearch}).
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "0").
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).Cohort("test-cohort").Obj(),
+			secondaryClusterQueue: utiltesting.MakeClusterQueue("test-secondary-clusterqueue").
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).
+				Cohort("test-cohort").
+				Obj(),
+			secondaryClusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: 10_000,
+			},
+			simulationResult: map[resources.FlavorResource]simulationResultForFlavor{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: {preemptioncommon.Preempt, 1},
+			},
+			wantRepMode: Preempt,
+			wantAssignment: Assignment{
+				Borrowing: 1,
+				PodSets: []PodSetAssignment{{
+					Name: kueue.DefaultPodSetName,
+					Flavors: ResourceAssignment{
+						corev1.ResourceCPU: {Name: "one", Mode: Preempt, TriedFlavorIdx: 0},
+					},
+					Status: *NewStatus("insufficient unused quota for cpu in flavor one, 10 more needed"),
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU: resource.MustParse("12"),
+					},
+					Count: 1,
+				}},
+				Usage: workload.Usage{Quota: resources.FlavorResourceQuantities{
+					{Flavor: "one", Resource: corev1.ResourceCPU}: 12_000,
+				}},
+			},
+		},
+		"when borrowing while preemption is needed for flavor one, fair sharing enabled, reclaimWithinCohort=Any; using deprecated WhenCanBorrow=Borrow,WhenCanPreempt=Preempt": {
 			enableFairSharing: true,
 			wlPods: []kueue.PodSet{
 				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
@@ -2109,6 +2427,55 @@ func TestAssignFlavors(t *testing.T) {
 			},
 		},
 		"when borrowing while preemption is needed for flavor one, fair sharing enabled, reclaimWithinCohort=Never": {
+			enableFairSharing: true,
+			wlPods: []kueue.PodSet{
+				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
+					Request(corev1.ResourceCPU, "12").
+					Obj(),
+			},
+			clusterQueue: *utiltesting.MakeClusterQueue("test-clusterqueue").
+				Preemption(kueue.ClusterQueuePreemption{ReclaimWithinCohort: kueue.PreemptionPolicyNever}).
+				FlavorFungibility(kueue.FlavorFungibility{WhenCanBorrow: kueue.MayStopSearch, WhenCanPreempt: kueue.MayStopSearch}).
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "0").
+						Obj(),
+					*utiltesting.MakeFlavorQuotas("two").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).Cohort("test-cohort").Obj(),
+			secondaryClusterQueue: utiltesting.MakeClusterQueue("test-secondary-clusterqueue").
+				ResourceGroup(
+					*utiltesting.MakeFlavorQuotas("one").
+						Resource(corev1.ResourceCPU, "12").
+						Obj(),
+				).
+				Cohort("test-cohort").
+				Obj(),
+			secondaryClusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: 10_000,
+			},
+			simulationResult: map[resources.FlavorResource]simulationResultForFlavor{
+				{Flavor: "one", Resource: corev1.ResourceCPU}: {preemptioncommon.NoCandidates, 0},
+			},
+			wantRepMode: Fit,
+			wantAssignment: Assignment{
+				PodSets: []PodSetAssignment{{
+					Name: kueue.DefaultPodSetName,
+					Flavors: ResourceAssignment{
+						corev1.ResourceCPU: {Name: "two", Mode: Fit, TriedFlavorIdx: -1},
+					},
+					Requests: corev1.ResourceList{
+						corev1.ResourceCPU: resource.MustParse("12"),
+					},
+					Count: 1,
+				}},
+				Usage: workload.Usage{Quota: resources.FlavorResourceQuantities{
+					{Flavor: "two", Resource: corev1.ResourceCPU}: 12_000,
+				}},
+			},
+		},
+		"when borrowing while preemption is needed for flavor one, fair sharing enabled, reclaimWithinCohort=Never; using deprecated WhenCanBorrow=Borrow,WhenCanPreempt=Preempt": {
 			enableFairSharing: true,
 			wlPods: []kueue.PodSet{
 				*utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).
@@ -2541,6 +2908,21 @@ func TestReclaimBeforePriorityPreemption(t *testing.T) {
 			wantAssigment: rfMap{"gpu": "due"},
 		},
 		"Select first flavor when flavor fungibility is disabled": {
+			workloadRequests: utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("gpu", "10"),
+			testClusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "uno", Resource: "gpu"}: 1,
+			},
+			otherClusterQueueUsage: resources.FlavorResourceQuantities{
+				{Flavor: "due", Resource: "gpu"}: 1,
+				{Flavor: "tre", Resource: "gpu"}: 1,
+			},
+			flavorFungibility: &kueue.FlavorFungibility{
+				WhenCanPreempt: kueue.MayStopSearch,
+			},
+			wantMode:      Preempt,
+			wantAssigment: rfMap{"gpu": "uno"},
+		},
+		"Select first flavor when flavor fungibility is disabled; using deprecated WhenCanPreempt=Preempt": {
 			workloadRequests: utiltesting.MakePodSet(kueue.DefaultPodSetName, 1).Request("gpu", "10"),
 			testClusterQueueUsage: resources.FlavorResourceQuantities{
 				{Flavor: "uno", Resource: "gpu"}: 1,
diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go
index 1d4ed4e89..b53307f63 100644
--- a/pkg/scheduler/scheduler_test.go
+++ b/pkg/scheduler/scheduler_test.go
@@ -205,14 +205,14 @@ func TestSchedule(t *testing.T) {
 
 		wantSkippedPreemptions map[string]int
 	}{
-		"use second flavor when the first has no preemption candidates; WhenCanPreempt: Preempt": {
+		"use second flavor when the first has no preemption candidates; WhenCanPreempt: MayStopSearch": {
 			additionalClusterQueues: []kueue.ClusterQueue{
 				*utiltesting.MakeClusterQueue("other-alpha").
 					Preemption(kueue.ClusterQueuePreemption{
 						WithinClusterQueue: kueue.PreemptionPolicyLowerPriority,
 					}).
 					FlavorFungibility(kueue.FlavorFungibility{
-						WhenCanPreempt: kueue.Preempt,
+						WhenCanPreempt: kueue.MayStopSearch,
 					}).
 					ResourceGroup(
 						*utiltesting.MakeFlavorQuotas("on-demand").
@@ -6290,8 +6290,8 @@ func TestSchedule(t *testing.T) {
 						},
 					}).
 					FlavorFungibility(kueue.FlavorFungibility{
-						WhenCanPreempt: kueue.Preempt,
-						WhenCanBorrow:  kueue.Borrow,
+						WhenCanPreempt: kueue.MayStopSearch,
+						WhenCanBorrow:  kueue.MayStopSearch,
 					}).
 					ResourceGroup(
 						*utiltesting.MakeFlavorQuotas("on-demand").
@@ -7401,8 +7401,8 @@ func TestLastSchedulingContext(t *testing.T) {
 				ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
 			}).
 			FlavorFungibility(kueue.FlavorFungibility{
-				WhenCanPreempt: kueue.Preempt,
-				WhenCanBorrow:  kueue.Borrow,
+				WhenCanPreempt: kueue.MayStopSearch,
+				WhenCanBorrow:  kueue.MayStopSearch,
 			}).
 			ResourceGroup(
 				*utiltesting.MakeFlavorQuotas("on-demand").
@@ -7418,8 +7418,8 @@ func TestLastSchedulingContext(t *testing.T) {
 				ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
 			}).
 			FlavorFungibility(kueue.FlavorFungibility{
-				WhenCanPreempt: kueue.Preempt,
-				WhenCanBorrow:  kueue.Borrow,
+				WhenCanPreempt: kueue.MayStopSearch,
+				WhenCanBorrow:  kueue.MayStopSearch,
 			}).
 			ResourceGroup(
 				*utiltesting.MakeFlavorQuotas("on-demand").
@@ -7473,7 +7473,7 @@ func TestLastSchedulingContext(t *testing.T) {
 						WithinClusterQueue: kueue.PreemptionPolicyLowerPriority,
 					}).
 					FlavorFungibility(kueue.FlavorFungibility{
-						WhenCanPreempt: kueue.Preempt,
+						WhenCanPreempt: kueue.MayStopSearch,
 					}).
 					ResourceGroup(
 						*utiltesting.MakeFlavorQuotas("on-demand").
diff --git a/pkg/util/testing/wrappers.go b/pkg/util/testing/wrappers.go
index 51c3abebd..8b57d0096 100644
--- a/pkg/util/testing/wrappers.go
+++ b/pkg/util/testing/wrappers.go
@@ -839,7 +839,7 @@ func MakeClusterQueue(name string) *ClusterQueueWrapper {
 			NamespaceSelector: &metav1.LabelSelector{},
 			QueueingStrategy:  kueue.BestEffortFIFO,
 			FlavorFungibility: &kueue.FlavorFungibility{
-				WhenCanBorrow:  kueue.Borrow,
+				WhenCanBorrow:  kueue.MayStopSearch,
 				WhenCanPreempt: kueue.TryNextFlavor,
 			},
 		},
diff --git a/test/integration/singlecluster/controller/jobs/job/job_controller_test.go b/test/integration/singlecluster/controller/jobs/job/job_controller_test.go
index 92543d37d..a303320de 100644
--- a/test/integration/singlecluster/controller/jobs/job/job_controller_test.go
+++ b/test/integration/singlecluster/controller/jobs/job/job_controller_test.go
@@ -1343,7 +1343,7 @@ var _ = ginkgo.Describe("Interacting with scheduler", ginkgo.Ordered, ginkgo.Con
 				*testing.MakeFlavorQuotas("on-demand").Resource(corev1.ResourceCPU, "5").Obj(),
 			).
 			FlavorFungibility(kueue.FlavorFungibility{
-				WhenCanBorrow:  kueue.Borrow,
+				WhenCanBorrow:  kueue.MayStopSearch,
 				WhenCanPreempt: kueue.TryNextFlavor,
 			}).
 			Preemption(kueue.ClusterQueuePreemption{
diff --git a/test/integration/singlecluster/scheduler/preemption_test.go b/test/integration/singlecluster/scheduler/preemption_test.go
index 222dfe13c..63a0f3d66 100644
--- a/test/integration/singlecluster/scheduler/preemption_test.go
+++ b/test/integration/singlecluster/scheduler/preemption_test.go
@@ -570,8 +570,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 					*testing.MakeFlavorQuotas("fallback").Resource(corev1.ResourceCPU, "10", "0").Obj(),
 				).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
@@ -592,8 +592,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 					*testing.MakeFlavorQuotas("fallback").Resource(corev1.ResourceCPU, "10", "0").Obj(),
 				).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
@@ -613,8 +613,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 					*testing.MakeFlavorQuotas("fallback").Resource(corev1.ResourceCPU, "10", "0").Obj(),
 				).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
@@ -634,8 +634,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 					*testing.MakeFlavorQuotas("fallback").Resource(corev1.ResourceCPU, "10", "0").Obj(),
 				).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyLowerPriority,
@@ -819,8 +819,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 					*testing.MakeFlavorQuotas("default").Resource(corev1.ResourceCPU, "0", "10").Obj(),
 				).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyAny,
@@ -837,8 +837,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 					*testing.MakeFlavorQuotas("default").Resource(corev1.ResourceCPU, "5", "5").Obj(),
 				).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyAny,
@@ -859,8 +859,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 					*testing.MakeFlavorQuotas("default").Resource(corev1.ResourceCPU, "5").Obj(),
 				).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanBorrow:  kueue.MayStopSearch,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyAny,
diff --git a/test/integration/singlecluster/scheduler/scheduler_test.go b/test/integration/singlecluster/scheduler/scheduler_test.go
index fe3a8b3f4..983bf98bd 100644
--- a/test/integration/singlecluster/scheduler/scheduler_test.go
+++ b/test/integration/singlecluster/scheduler/scheduler_test.go
@@ -1287,7 +1287,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 					WithinClusterQueue: kueue.PreemptionPolicyLowerPriority,
 				}).
 				FlavorFungibility(kueue.FlavorFungibility{
-					WhenCanPreempt: kueue.Preempt,
+					WhenCanPreempt: kueue.MayStopSearch,
 				}).
 				Obj()
 			util.MustCreate(ctx, k8sClient, prodCQ)
@@ -1368,7 +1368,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 				Preemption(kueue.ClusterQueuePreemption{
 					ReclaimWithinCohort: kueue.PreemptionPolicyAny,
 				}).
-				FlavorFungibility(kueue.FlavorFungibility{WhenCanPreempt: kueue.Preempt}).
+				FlavorFungibility(kueue.FlavorFungibility{WhenCanPreempt: kueue.MayStopSearch}).
 				Obj()
 			util.MustCreate(ctx, k8sClient, prodCQ)
 
@@ -2625,7 +2625,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 			ginkgo.It("chooses a correct flavor when preemption is preferred", func() {
 				fungibility := kueue.FlavorFungibility{
 					WhenCanBorrow:  kueue.TryNextFlavor,
-					WhenCanPreempt: kueue.Preempt}
+					WhenCanPreempt: kueue.MayStopSearch}
 				preemption := kueue.ClusterQueuePreemption{WithinClusterQueue: kueue.PreemptionPolicyLowerPriority, ReclaimWithinCohort: kueue.PreemptionPolicyAny, BorrowWithinCohort: &kueue.BorrowWithinCohort{Policy: kueue.BorrowWithinCohortPolicyLowerPriority}}
 
 				cq1 = createQueue(testing.MakeClusterQueue("cq1").
@@ -2672,7 +2672,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 			})
 			ginkgo.It("chooses a correct flavor when borrowing is preferred", func() {
 				fungibility := kueue.FlavorFungibility{
-					WhenCanBorrow:  kueue.Borrow,
+					WhenCanBorrow:  kueue.MayStopSearch,
 					WhenCanPreempt: kueue.TryNextFlavor}
 				preemption := kueue.ClusterQueuePreemption{WithinClusterQueue: kueue.PreemptionPolicyLowerPriority, ReclaimWithinCohort: kueue.PreemptionPolicyAny, BorrowWithinCohort: &kueue.BorrowWithinCohort{Policy: kueue.BorrowWithinCohortPolicyLowerPriority}}
 
diff --git a/test/integration/singlecluster/webhook/core/clusterqueue_test.go b/test/integration/singlecluster/webhook/core/clusterqueue_test.go
index 33e52d7aa..256529056 100644
--- a/test/integration/singlecluster/webhook/core/clusterqueue_test.go
+++ b/test/integration/singlecluster/webhook/core/clusterqueue_test.go
@@ -53,7 +53,7 @@ var _ = ginkgo.Describe("ClusterQueue Webhook", ginkgo.Ordered, func() {
 	})
 	var ns *corev1.Namespace
 	defaultFlavorFungibility := &kueue.FlavorFungibility{
-		WhenCanBorrow:  kueue.Borrow,
+		WhenCanBorrow:  kueue.MayStopSearch,
 		WhenCanPreempt: kueue.TryNextFlavor,
 	}
 
diff --git a/test/performance/e2e/podgroups/templates/cluster-queue.yaml b/test/performance/e2e/podgroups/templates/cluster-queue.yaml
index 22b84e1ce..4a5c9eb2e 100644
--- a/test/performance/e2e/podgroups/templates/cluster-queue.yaml
+++ b/test/performance/e2e/podgroups/templates/cluster-queue.yaml
@@ -7,8 +7,8 @@ metadata:
 spec:
   cohort: pod-performance-cohort-{{ (Mod .Index .NumCohorts) }}
   flavorFungibility:
-    whenCanBorrow: Borrow
-    whenCanPreempt: Preempt
+    whenCanBorrow: MayStopSearch
+    whenCanPreempt: MayStopSearch
   preemption:
     borrowWithinCohort:
       policy: Never