diff --git a/crates/config/src/invariant.rs b/crates/config/src/invariant.rs
index 15f8d4608ac5f..3eee864452b25 100644
--- a/crates/config/src/invariant.rs
+++ b/crates/config/src/invariant.rs
@@ -49,6 +49,10 @@ pub struct InvariantConfig {
     ///
     /// Example: `check_interval = 10` means assert after calls 10, 20, 30, ... and the last call.
     pub check_interval: u32,
+    /// Assert every invariant declared in the current test suite, continuing the campaign after
+    /// the first failure until all invariants have been broken (or normal limits are hit).
+    /// When `false`, the campaign aborts on the first broken invariant (legacy behavior).
+    pub assert_all: bool,
 }
 
 impl Default for InvariantConfig {
@@ -70,6 +74,7 @@ impl Default for InvariantConfig {
             max_time_delay: None,
             max_block_delay: None,
             check_interval: 1,
+            assert_all: true,
         }
     }
 }
diff --git a/crates/evm/evm/src/executors/corpus.rs b/crates/evm/evm/src/executors/corpus.rs
index 3c48e30dd239d..856379f6f81f0 100644
--- a/crates/evm/evm/src/executors/corpus.rs
+++ b/crates/evm/evm/src/executors/corpus.rs
@@ -220,6 +220,7 @@ pub(crate) struct CorpusMetrics {
 impl fmt::Display for CorpusMetrics {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f)?;
+        writeln!(f, "      Edge coverage metrics:")?;
         writeln!(f, "        - cumulative edges seen: {}", self.cumulative_edges_seen)?;
         writeln!(f, "        - cumulative features seen: {}", self.cumulative_features_seen)?;
         writeln!(f, "        - corpus count: {}", self.corpus_count)?;
diff --git a/crates/evm/evm/src/executors/invariant/error.rs b/crates/evm/evm/src/executors/invariant/error.rs
index 4f1cd5ebbfa36..0549086fa3bb4 100644
--- a/crates/evm/evm/src/executors/invariant/error.rs
+++ b/crates/evm/evm/src/executors/invariant/error.rs
@@ -1,13 +1,14 @@
 use super::InvariantContract;
 use crate::executors::RawCallResult;
+use alloy_json_abi::Function;
 use alloy_primitives::{Address, Bytes};
-use foundry_config::InvariantConfig;
 use foundry_evm_core::{
     decode::{ASSERTION_FAILED_PREFIX, EMPTY_REVERT_DATA, RevertDecoder},
     evm::FoundryEvmNetwork,
 };
 use foundry_evm_fuzz::{BasicTxDetails, Reason, invariant::FuzzRunIdentifiedContracts};
 use proptest::test_runner::TestError;
+use std::{collections::HashMap, fmt};
 
 /// Stores information about failures and reverts of the invariant tests.
 #[derive(Clone, Default)]
@@ -17,7 +18,7 @@ pub struct InvariantFailures {
     /// The latest revert reason of a run.
     pub revert_reason: Option<String>,
     /// Maps a broken invariant to its specific error.
-    pub error: Option<InvariantFuzzError>,
+    pub errors: HashMap<String, InvariantFuzzError>,
 }
 
 impl InvariantFailures {
@@ -25,8 +26,33 @@ impl InvariantFailures {
         Self::default()
     }
 
-    pub fn into_inner(self) -> (usize, Option<InvariantFuzzError>) {
-        (self.reverts, self.error)
+    pub fn into_inner(self) -> (usize, HashMap<String, InvariantFuzzError>) {
+        (self.reverts, self.errors)
+    }
+
+    pub fn record_failure(&mut self, invariant: &Function, failure: InvariantFuzzError) {
+        self.errors.insert(invariant.name.clone(), failure);
+    }
+
+    pub fn has_failure(&self, invariant: &Function) -> bool {
+        self.errors.contains_key(&invariant.name)
+    }
+
+    pub fn get_failure(&self, invariant: &Function) -> Option<&InvariantFuzzError> {
+        self.errors.get(&invariant.name)
+    }
+
+    pub fn can_continue(&self, invariants: usize) -> bool {
+        debug_assert!(invariants > 0, "invariant_fns must not be empty");
+        self.errors.len() < invariants
+    }
+}
+
+impl fmt::Display for InvariantFailures {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f)?;
+        writeln!(f, "      ❌ Failures: {}", self.errors.len())?;
+        Ok(())
     }
 }
 
@@ -75,7 +101,8 @@ pub struct FailedInvariantCaseData {
 impl FailedInvariantCaseData {
     pub fn new<FEN: FoundryEvmNetwork>(
         invariant_contract: &InvariantContract<'_>,
-        invariant_config: &InvariantConfig,
+        shrink_run_limit: u32,
+        fail_on_revert: bool,
         targeted_contracts: &FuzzRunIdentifiedContracts,
         calldata: &[BasicTxDetails],
         call_result: RawCallResult<FEN>,
@@ -95,7 +122,7 @@ impl FailedInvariantCaseData {
                 revert_reason
             };
 
-        let func = invariant_contract.invariant_function;
+        let func = invariant_contract.primary_invariant_fn;
         debug_assert!(func.inputs.is_empty());
         let origin = func.name.as_str();
         Self {
@@ -108,8 +135,8 @@ impl FailedInvariantCaseData {
             addr: invariant_contract.address,
             calldata: func.selector().to_vec().into(),
             inner_sequence: inner_sequence.to_vec(),
-            shrink_run_limit: invariant_config.shrink_run_limit,
-            fail_on_revert: invariant_config.fail_on_revert,
+            shrink_run_limit,
+            fail_on_revert,
             assertion_failure: false,
         }
     }
diff --git a/crates/evm/evm/src/executors/invariant/mod.rs b/crates/evm/evm/src/executors/invariant/mod.rs
index 27d8e6a0ed588..b24ab0b3d9b4d 100644
--- a/crates/evm/evm/src/executors/invariant/mod.rs
+++ b/crates/evm/evm/src/executors/invariant/mod.rs
@@ -5,6 +5,7 @@ use crate::{
     },
     inspectors::Fuzzer,
 };
+use alloy_json_abi::Function;
 use alloy_primitives::{Address, Bytes, FixedBytes, I256, Selector, U256, map::AddressMap};
 use alloy_sol_types::{SolCall, sol};
 use eyre::{ContextCompat, Result, eyre};
@@ -34,7 +35,7 @@ use foundry_evm_traces::{CallTraceArena, SparsedTraceArena};
 use indicatif::ProgressBar;
 use parking_lot::RwLock;
 use proptest::{strategy::Strategy, test_runner::TestRunner};
-use result::{assert_after_invariant, assert_invariants, can_continue, did_fail_on_assert};
+use result::{assert_after_invariant, can_continue, did_fail_on_assert, invariant_preflight_check};
 use revm::{context::Block, state::Account};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -179,6 +180,23 @@ impl InvariantFailureMetrics {
     }
 }
 
+/// Returns the (name, reason) of the first broken invariant in declaration order. Falls back
+/// to the primary's name with an empty reason if `failures.errors` is somehow empty.
+fn first_broken_event<'a>(
+    invariant_contract: &'a InvariantContract<'_>,
+    failures: &InvariantFailures,
+) -> (&'a str, String) {
+    invariant_contract
+        .invariant_fns
+        .iter()
+        .find_map(|(f, _)| {
+            failures
+                .get_failure(f)
+                .map(|e| (f.name.as_str(), e.revert_reason().unwrap_or_default()))
+        })
+        .unwrap_or((invariant_contract.primary_invariant_fn.name.as_str(), String::new()))
+}
+
 /// Builds the machine-readable invariant progress payload emitted during a
 /// campaign.
 ///
@@ -219,7 +237,7 @@ fn build_invariant_progress_json<M: Serialize>(
 }
 
 /// Contains data collected during invariant test runs.
-struct InvariantTestData<FEN: FoundryEvmNetwork> {
+struct InvariantTestData {
     // Consumed gas and calldata of every successful fuzz call.
     fuzz_cases: Vec<FuzzedCases>,
     // Data related to reverts or failed assertions of the test.
@@ -228,8 +246,6 @@ struct InvariantTestData<FEN: FoundryEvmNetwork> {
     last_run_inputs: Vec<BasicTxDetails>,
     // Additional traces for gas report.
     gas_report_traces: Vec<Vec<CallTraceArena>>,
-    // Last call results of the invariant test.
-    last_call_results: Option<RawCallResult<FEN>>,
     // Line coverage information collected from all fuzzed calls.
     line_coverage: Option<HitMaps>,
     // Metrics for each fuzzed selector.
@@ -248,34 +264,28 @@ struct InvariantTestData<FEN: FoundryEvmNetwork> {
 }
 
 /// Contains invariant test data.
-struct InvariantTest<FEN: FoundryEvmNetwork> {
+struct InvariantTest {
     // Fuzz state of invariant test.
     fuzz_state: EvmFuzzState,
     // Contracts fuzzed by the invariant test.
     targeted_contracts: FuzzRunIdentifiedContracts,
     // Data collected during invariant runs.
-    test_data: InvariantTestData<FEN>,
+    test_data: InvariantTestData,
 }
 
-impl<FEN: FoundryEvmNetwork> InvariantTest<FEN> {
+impl InvariantTest {
     /// Instantiates an invariant test.
     fn new(
         fuzz_state: EvmFuzzState,
         targeted_contracts: FuzzRunIdentifiedContracts,
         failures: InvariantFailures,
-        last_call_results: Option<RawCallResult<FEN>>,
         branch_runner: TestRunner,
     ) -> Self {
-        let mut fuzz_cases = vec![];
-        if last_call_results.is_none() {
-            fuzz_cases.push(FuzzedCases::new(vec![]));
-        }
         let test_data = InvariantTestData {
-            fuzz_cases,
+            fuzz_cases: vec![],
             failures,
             last_run_inputs: vec![],
             gas_report_traces: vec![],
-            last_call_results,
             line_coverage: None,
             metrics: Map::default(),
             branch_runner,
@@ -290,19 +300,9 @@ impl<FEN: FoundryEvmNetwork> InvariantTest<FEN> {
         self.test_data.failures.reverts
     }
 
-    /// Whether invariant test has errors or not.
-    const fn has_errors(&self) -> bool {
-        self.test_data.failures.error.is_some()
-    }
-
     /// Set invariant test error.
-    fn set_error(&mut self, error: InvariantFuzzError) {
-        self.test_data.failures.error = Some(error);
-    }
-
-    /// Set last invariant test call results.
-    fn set_last_call_results(&mut self, call_result: Option<RawCallResult<FEN>>) {
-        self.test_data.last_call_results = call_result;
+    fn set_error(&mut self, invariant: &Function, error: InvariantFuzzError) {
+        self.test_data.failures.record_failure(invariant, error);
     }
 
     /// Set last invariant run call sequence.
@@ -335,7 +335,7 @@ impl<FEN: FoundryEvmNetwork> InvariantTest<FEN> {
 
     /// End invariant test run by collecting results, cleaning collected artifacts and reverting
     /// created fuzz state.
-    fn end_run(&mut self, run: InvariantTestRun<FEN>, gas_samples: usize) {
+    fn end_run<FEN: FoundryEvmNetwork>(&mut self, run: InvariantTestRun<FEN>, gas_samples: usize) {
         // We clear all the targeted contracts created during this run.
         self.targeted_contracts.clear_created_contracts(run.created_contracts);
 
@@ -455,7 +455,7 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
         early_exit: &EarlyExit,
     ) -> Result<InvariantFuzzTestResult> {
         // Throw an error to abort test run if the invariant function accepts input params
-        if !invariant_contract.invariant_function.inputs.is_empty() {
+        if !invariant_contract.primary_invariant_fn.inputs.is_empty() {
             return Err(eyre!("Invariant test function should have no inputs"));
         }
 
@@ -481,6 +481,9 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
         let edge_coverage_enabled = self.config.corpus.collect_edge_coverage();
 
         'stop: while continue_campaign(runs) {
+            // Per-run failure count snapshot used to gate `afterInvariant` below.
+            let failures_before_run = invariant_test.test_data.failures.errors.len();
+
             let initial_seq = corpus_manager.new_inputs(
                 &mut invariant_test.test_data.branch_runner,
                 &invariant_test.fuzz_state,
@@ -534,9 +537,10 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                     current_run.inputs.pop();
                     current_run.rejects += 1;
                     if current_run.rejects > self.config.max_assume_rejects {
-                        invariant_test.set_error(InvariantFuzzError::MaxAssumeRejects(
-                            self.config.max_assume_rejects,
-                        ));
+                        invariant_test.set_error(
+                            invariant_contract.primary_invariant_fn,
+                            InvariantFuzzError::MaxAssumeRejects(self.config.max_assume_rejects),
+                        );
                         break 'stop;
                     }
                 } else {
@@ -621,7 +625,8 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                         {
                             let case_data = error::FailedInvariantCaseData::new(
                                 &invariant_contract,
-                                &self.config,
+                                self.config.shrink_run_limit,
+                                self.config.fail_on_revert,
                                 &invariant_test.targeted_contracts,
                                 &current_run.inputs,
                                 call_result,
@@ -630,12 +635,15 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                             .with_assertion_failure(assertion_failure);
                             invariant_test.test_data.failures.revert_reason =
                                 Some(case_data.revert_reason.clone());
-                            invariant_test.test_data.failures.error = Some(if assertion_failure {
-                                InvariantFuzzError::BrokenInvariant(case_data)
-                            } else {
-                                InvariantFuzzError::Revert(case_data)
-                            });
-                            result::RichInvariantResults::new(false, None)
+                            invariant_test.set_error(
+                                invariant_contract.primary_invariant_fn,
+                                if assertion_failure {
+                                    InvariantFuzzError::BrokenInvariant(case_data)
+                                } else {
+                                    InvariantFuzzError::Revert(case_data)
+                                },
+                            );
+                            false
                         } else if call_result.reverted
                             && !invariant_contract.is_optimization()
                             && !self.config.has_delay()
@@ -644,33 +652,28 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                             // preserve their warp/roll contribution when building the final
                             // counterexample.
                             current_run.inputs.pop();
-                            result::RichInvariantResults::new(true, None)
+                            true
                         } else {
-                            result::RichInvariantResults::new(true, None)
+                            true
                         }
                     };
 
-                    if !result.can_continue || current_run.depth == self.config.depth - 1 {
+                    if !result || current_run.depth == self.config.depth - 1 {
                         invariant_test.set_last_run_inputs(&current_run.inputs);
                     }
                     // If test cannot continue then stop current run and exit test suite.
-                    if !result.can_continue {
-                        let reason = invariant_test
-                            .test_data
-                            .failures
-                            .error
-                            .as_ref()
-                            .and_then(|e| e.revert_reason())
-                            .unwrap_or_default();
-                        failure_metrics.record_failure(
-                            &invariant_contract.invariant_function.name,
-                            invariant_contract.name,
-                            &reason,
+                    if !result {
+                        // Attribute the failure event to the first invariant in declaration
+                        // order whose entry is in `failures.errors`. Avoids the nondeterminism
+                        // of `errors.values().next()` (HashMap RandomState) and keeps the
+                        // event's `invariant` and `reason` fields self-consistent.
+                        let (name, reason) = first_broken_event(
+                            &invariant_contract,
+                            &invariant_test.test_data.failures,
                         );
+                        failure_metrics.record_failure(name, invariant_contract.name, &reason);
                         break 'stop;
                     }
-
-                    invariant_test.set_last_call_results(result.call_result);
                     current_run.depth += 1;
                 }
 
@@ -695,8 +698,12 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                 optimization,
             );
 
-            // Call `afterInvariant` only if it is declared and test didn't fail already.
-            if invariant_contract.call_after_invariant && !invariant_test.has_errors() {
+            // Call `afterInvariant` only if declared and the current run produced no new
+            // failure. Under `assert_all` the campaign keeps running after earlier failures,
+            // but the hook must still execute on subsequent runs.
+            if invariant_contract.call_after_invariant
+                && invariant_test.test_data.failures.errors.len() == failures_before_run
+            {
                 let success = assert_after_invariant(
                     &invariant_contract,
                     &mut invariant_test,
@@ -705,18 +712,11 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                 )
                 .map_err(|_| eyre!("Failed to call afterInvariant"))?;
                 if !success {
-                    let reason = invariant_test
-                        .test_data
-                        .failures
-                        .error
-                        .as_ref()
-                        .and_then(|e| e.revert_reason())
-                        .unwrap_or_default();
-                    failure_metrics.record_failure(
-                        &invariant_contract.invariant_function.name,
-                        invariant_contract.name,
-                        &reason,
-                    );
+                    // Same as the in-run failure path above: attribute to the first broken
+                    // invariant in declaration order so the event is deterministic.
+                    let (name, reason) =
+                        first_broken_event(&invariant_contract, &invariant_test.test_data.failures);
+                    failure_metrics.record_failure(name, invariant_contract.name, &reason);
                 }
             }
 
@@ -725,9 +725,11 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
             if let Some(progress) = progress {
                 // If running with progress then increment completed runs.
                 progress.inc(1);
-                // Display current best value and/or corpus metrics in progress bar.
+                // Display current best value, corpus metrics, and failure counts.
                 let best = invariant_test.test_data.optimization_best_value;
-                if edge_coverage_enabled || best.is_some() {
+                let broken = invariant_test.test_data.failures.errors.len();
+                let total_invariants = invariant_contract.invariant_fns.len();
+                if edge_coverage_enabled || best.is_some() || broken > 0 {
                     let mut msg = String::new();
                     if let Some(best) = best {
                         msg.push_str(&format!("best: {best}"));
@@ -738,6 +740,12 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                         }
                         msg.push_str(&format!("{}", &corpus_manager.metrics));
                     }
+                    if broken > 0 {
+                        if !msg.is_empty() {
+                            msg.push_str(", ");
+                        }
+                        msg.push_str(&format!("❌ {broken}/{total_invariants} broken"));
+                    }
                     progress.set_message(msg);
                 }
             } else if edge_coverage_enabled
@@ -746,7 +754,7 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
                 // Display corpus metrics inline as JSON.
                 let metrics = build_invariant_progress_json(
                     SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs(),
-                    &invariant_contract.invariant_function.name,
+                    &invariant_contract.primary_invariant_fn.name,
                     &corpus_manager.metrics,
                     invariant_test.test_data.optimization_best_value,
                     throughput,
@@ -765,7 +773,7 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
 
         let result = invariant_test.test_data;
         Ok(InvariantFuzzTestResult {
-            error: result.failures.error,
+            errors: result.failures.errors,
             cases: result.fuzz_cases,
             reverts: result.failures.reverts,
             last_run_inputs: result.last_run_inputs,
@@ -786,7 +794,7 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
         invariant_contract: &InvariantContract<'_>,
         fuzz_fixtures: &FuzzFixtures,
         fuzz_state: EvmFuzzState,
-    ) -> Result<(InvariantTest<FEN>, WorkerCorpus)> {
+    ) -> Result<(InvariantTest, WorkerCorpus)> {
         // Finds out the chosen deployed contracts and/or senders.
         self.select_contract_artifacts(invariant_contract.address)?;
         let (targeted_senders, targeted_contracts) =
@@ -825,7 +833,7 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
         // already know if we can early exit the invariant run.
         // This does not count as a fuzz run. It will just register the revert.
         let mut failures = InvariantFailures::new();
-        let last_call_results = assert_invariants(
+        invariant_preflight_check(
             invariant_contract,
             &self.config,
             &targeted_contracts,
@@ -833,7 +841,13 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
             &[],
             &mut failures,
         )?;
-        if let Some(error) = failures.error {
+        // Prefer primary invariant's error; fall back to the first broken invariant in
+        // declaration order (deterministic, unlike HashMap iteration).
+        if let Some(error) =
+            failures.get_failure(invariant_contract.primary_invariant_fn).or_else(|| {
+                invariant_contract.invariant_fns.iter().find_map(|(f, _)| failures.get_failure(f))
+            })
+        {
             return Err(eyre!(error.revert_reason().unwrap_or_default()));
         }
 
@@ -875,13 +889,8 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
             Some(&targeted_contracts),
         )?;
 
-        let mut invariant_test = InvariantTest::new(
-            fuzz_state,
-            targeted_contracts,
-            failures,
-            last_call_results,
-            self.runner.clone(),
-        );
+        let mut invariant_test =
+            InvariantTest::new(fuzz_state, targeted_contracts, failures, self.runner.clone());
 
         // Seed invariant test with previously persisted optimization state,
         // but only if the current invariant is in optimization mode.
@@ -1227,7 +1236,7 @@ impl<'a, FEN: FoundryEvmNetwork> InvariantExecutor<'a, FEN> {
 /// before inserting it into the dictionary. Otherwise, we flood the dictionary with
 /// randomly generated addresses.
 fn collect_data<FEN: FoundryEvmNetwork>(
-    invariant_test: &InvariantTest<FEN>,
+    invariant_test: &InvariantTest,
     state_changeset: &mut AddressMap<Account>,
     tx: &BasicTxDetails,
     call_result: &RawCallResult<FEN>,
diff --git a/crates/evm/evm/src/executors/invariant/replay.rs b/crates/evm/evm/src/executors/invariant/replay.rs
index 19fc7cdc7e45d..134f22d0a1f29 100644
--- a/crates/evm/evm/src/executors/invariant/replay.rs
+++ b/crates/evm/evm/src/executors/invariant/replay.rs
@@ -1,9 +1,10 @@
 use super::{call_after_invariant_function, call_invariant_function, execute_tx};
 use crate::executors::{
     EarlyExit, Executor,
-    invariant::shrink::{shrink_sequence, shrink_sequence_value},
+    invariant::shrink::{reset_shrink_progress, shrink_sequence, shrink_sequence_value},
 };
 use alloy_dyn_abi::JsonAbiExt;
+use alloy_json_abi::Function;
 use alloy_primitives::{I256, Log, map::HashMap};
 use eyre::Result;
 use foundry_common::{ContractsByAddress, ContractsByArtifact};
@@ -21,6 +22,7 @@ use std::sync::Arc;
 #[expect(clippy::too_many_arguments)]
 pub fn replay_run<FEN: FoundryEvmNetwork>(
     invariant_contract: &InvariantContract<'_>,
+    target_invariant: &Function,
     mut executor: Executor<FEN>,
     known_contracts: &ContractsByArtifact,
     mut ided_contracts: ContractsByAddress,
@@ -69,7 +71,7 @@ pub fn replay_run<FEN: FoundryEvmNetwork>(
     let (invariant_result, invariant_success) = call_invariant_function(
         &executor,
         invariant_contract.address,
-        invariant_contract.invariant_function.abi_encode_input(&[])?.into(),
+        target_invariant.abi_encode_input(&[])?.into(),
     )?;
     traces.push((TraceKind::Execution, invariant_result.traces.clone().unwrap()));
     logs.extend(invariant_result.logs);
@@ -104,6 +106,7 @@ pub fn replay_error<FEN: FoundryEvmNetwork>(
     expect_assertion_failure: bool,
     target_value: Option<I256>,
     invariant_contract: &InvariantContract<'_>,
+    target_invariant: &Function,
     known_contracts: &ContractsByArtifact,
     ided_contracts: ContractsByAddress,
     logs: &mut Vec<Log>,
@@ -112,11 +115,18 @@ pub fn replay_error<FEN: FoundryEvmNetwork>(
     deprecated_cheatcodes: &mut HashMap<&'static str, Option<&'static str>>,
     progress: Option<&ProgressBar>,
     early_exit: &EarlyExit,
+    position: Option<(usize, usize)>,
 ) -> Result<Vec<BaseCounterExample>> {
+    // Reset progress bar for this invariant's shrink phase. Multi-invariant runs call this once
+    // per target so the bar's message reflects which invariant is currently being shrunk and
+    // (when more than one invariant needs shrinking) the `[i/N]` counter shows queue depth.
+    reset_shrink_progress(&config, progress, &target_invariant.name, position);
+
     let calls = if let Some(target) = target_value {
         shrink_sequence_value(
             &config,
             invariant_contract,
+            target_invariant,
             calls,
             &executor,
             target,
@@ -127,6 +137,7 @@ pub fn replay_error<FEN: FoundryEvmNetwork>(
         shrink_sequence(
             &config,
             invariant_contract,
+            target_invariant,
             calls,
             expect_assertion_failure,
             &executor,
@@ -141,6 +152,7 @@ pub fn replay_error<FEN: FoundryEvmNetwork>(
 
     replay_run(
         invariant_contract,
+        target_invariant,
         executor,
         known_contracts,
         ided_contracts,
diff --git a/crates/evm/evm/src/executors/invariant/result.rs b/crates/evm/evm/src/executors/invariant/result.rs
index 0c14ae1641998..e624da6520e00 100644
--- a/crates/evm/evm/src/executors/invariant/result.rs
+++ b/crates/evm/evm/src/executors/invariant/result.rs
@@ -27,7 +27,8 @@ use std::{borrow::Cow, collections::HashMap};
 /// The outcome of an invariant fuzz test
 #[derive(Debug)]
 pub struct InvariantFuzzTestResult {
-    pub error: Option<InvariantFuzzError>,
+    /// Errors recorded per invariant.
+    pub errors: HashMap<String, InvariantFuzzError>,
     /// Every successful fuzz test case
     pub cases: Vec<FuzzedCases>,
     /// Number of reverted fuzz calls
@@ -50,18 +51,25 @@ pub struct InvariantFuzzTestResult {
     pub optimization_best_sequence: Vec<BasicTxDetails>,
 }
 
-/// Enriched results of an invariant run check.
-///
-/// Contains the success condition and call results of the last run
-pub(crate) struct RichInvariantResults<FEN: FoundryEvmNetwork> {
-    pub(crate) can_continue: bool,
-    pub(crate) call_result: Option<RawCallResult<FEN>>,
-}
-
-impl<FEN: FoundryEvmNetwork> RichInvariantResults<FEN> {
-    pub(crate) const fn new(can_continue: bool, call_result: Option<RawCallResult<FEN>>) -> Self {
-        Self { can_continue, call_result }
-    }
+/// Given the executor state, asserts that no invariant has been broken. Otherwise, it fills the
+/// external `invariant_failures.failed_invariant` map and returns a generic error.
+/// Either returns the call result if successful, or nothing if there was an error.
+pub(crate) fn invariant_preflight_check<FEN: FoundryEvmNetwork>(
+    invariant_contract: &InvariantContract<'_>,
+    invariant_config: &InvariantConfig,
+    targeted_contracts: &FuzzRunIdentifiedContracts,
+    executor: &Executor<FEN>,
+    calldata: &[BasicTxDetails],
+    invariant_failures: &mut InvariantFailures,
+) -> Result<()> {
+    assert_invariants(
+        invariant_contract,
+        invariant_config,
+        targeted_contracts,
+        executor,
+        calldata,
+        invariant_failures,
+    )
 }
 
 /// Returns true if this call failed due to a Solidity assertion:
@@ -130,37 +138,50 @@ pub(crate) fn assert_invariants<FEN: FoundryEvmNetwork>(
     executor: &Executor<FEN>,
     calldata: &[BasicTxDetails],
     invariant_failures: &mut InvariantFailures,
-) -> Result<Option<RawCallResult<FEN>>> {
-    let mut inner_sequence = vec![];
+) -> Result<()> {
+    let inner_sequence = invariant_inner_sequence(executor);
 
-    if let Some(fuzzer) = &executor.inspector().fuzzer
-        && let Some(call_generator) = &fuzzer.call_generator
-    {
-        inner_sequence.extend(call_generator.last_sequence.read().iter().cloned());
-    }
-
-    let (call_result, success) = call_invariant_function(
-        executor,
-        invariant_contract.address,
-        invariant_contract.invariant_function.abi_encode_input(&[])?.into(),
-    )?;
-    if !success {
+    for (invariant, fail_on_revert) in &invariant_contract.invariant_fns {
         // We only care about invariants which we haven't broken yet.
-        if invariant_failures.error.is_none() {
-            let case_data = FailedInvariantCaseData::new(
-                invariant_contract,
-                invariant_config,
-                targeted_contracts,
-                calldata,
-                call_result,
-                &inner_sequence,
+        if invariant_failures.has_failure(invariant) {
+            continue;
+        }
+
+        let (call_result, success) = call_invariant_function(
+            executor,
+            invariant_contract.address,
+            invariant.abi_encode_input(&[])?.into(),
+        )?;
+        if !success {
+            invariant_failures.record_failure(
+                invariant,
+                InvariantFuzzError::BrokenInvariant(FailedInvariantCaseData::new(
+                    invariant_contract,
+                    invariant_config.shrink_run_limit,
+                    *fail_on_revert,
+                    targeted_contracts,
+                    calldata,
+                    call_result,
+                    &inner_sequence,
+                )),
             );
-            invariant_failures.error = Some(InvariantFuzzError::BrokenInvariant(case_data));
-            return Ok(None);
         }
     }
 
-    Ok(Some(call_result))
+    Ok(())
+}
+
+/// Helper function to initialize invariant inner sequence.
+fn invariant_inner_sequence<FEN: FoundryEvmNetwork>(
+    executor: &Executor<FEN>,
+) -> Vec<Option<BasicTxDetails>> {
+    let mut seq = vec![];
+    if let Some(fuzzer) = &executor.inspector().fuzzer
+        && let Some(call_generator) = &fuzzer.call_generator
+    {
+        seq.extend(call_generator.last_sequence.read().iter().cloned());
+    }
+    seq
 }
 
 /// Returns if invariant test can continue and last successful call result of the invariant test
@@ -170,13 +191,12 @@ pub(crate) fn assert_invariants<FEN: FoundryEvmNetwork>(
 /// For check mode, asserts the invariant and fails if broken.
 pub(crate) fn can_continue<FEN: FoundryEvmNetwork>(
     invariant_contract: &InvariantContract<'_>,
-    invariant_test: &mut InvariantTest<FEN>,
+    invariant_test: &mut InvariantTest,
     invariant_run: &mut InvariantTestRun<FEN>,
     invariant_config: &InvariantConfig,
     call_result: RawCallResult<FEN>,
     state_changeset: &StateChangeset,
-) -> Result<RichInvariantResults<FEN>> {
-    let mut call_results = None;
+) -> Result<bool> {
     let is_optimization = invariant_contract.is_optimization();
 
     let handlers_succeeded = || {
@@ -200,7 +220,7 @@ pub(crate) fn can_continue<FEN: FoundryEvmNetwork>(
             let (inv_result, success) = call_invariant_function(
                 &invariant_run.executor,
                 invariant_contract.address,
-                invariant_contract.invariant_function.abi_encode_input(&[])?.into(),
+                invariant_contract.primary_invariant_fn.abi_encode_input(&[])?.into(),
             )?;
             if success
                 && inv_result.result.len() >= 32
@@ -214,10 +234,9 @@ pub(crate) fn can_continue<FEN: FoundryEvmNetwork>(
                     invariant_run.optimization_prefix_len = invariant_run.inputs.len();
                 }
             }
-            call_results = Some(inv_result);
         } else {
             // Check mode: assert invariants and fail if broken.
-            call_results = assert_invariants(
+            assert_invariants(
                 invariant_contract,
                 invariant_config,
                 &invariant_test.targeted_contracts,
@@ -225,51 +244,68 @@ pub(crate) fn can_continue<FEN: FoundryEvmNetwork>(
                 &invariant_run.inputs,
                 &mut invariant_test.test_data.failures,
             )?;
-            if call_results.is_none() {
-                return Ok(RichInvariantResults::new(false, None));
-            }
         }
     } else {
-        let invariant_data = &mut invariant_test.test_data;
         let is_assert_failure = did_fail_on_assert(&call_result, state_changeset);
+        let reverted = call_result.reverted;
 
-        if call_result.reverted {
-            invariant_data.failures.reverts += 1;
+        if reverted {
+            invariant_test.test_data.failures.reverts += 1;
         }
 
-        if is_assert_failure || (call_result.reverted && invariant_config.fail_on_revert) {
-            let case_data = FailedInvariantCaseData::new(
+        // Collect which invariants should be marked as failed due to this revert/assertion.
+        let failing_invariants: Vec<_> = invariant_contract
+            .invariant_fns
+            .iter()
+            .filter(|(invariant, fail_on_revert)| {
+                (is_assert_failure || *fail_on_revert)
+                    && !invariant_test.test_data.failures.has_failure(invariant)
+            })
+            .collect();
+
+        if !failing_invariants.is_empty() {
+            let base = FailedInvariantCaseData::new(
                 invariant_contract,
-                invariant_config,
+                invariant_config.shrink_run_limit,
+                invariant_config.fail_on_revert,
                 &invariant_test.targeted_contracts,
                 &invariant_run.inputs,
                 call_result,
                 &[],
             )
             .with_assertion_failure(is_assert_failure);
-            invariant_data.failures.revert_reason = Some(case_data.revert_reason.clone());
-            invariant_data.failures.error = Some(if is_assert_failure {
-                InvariantFuzzError::BrokenInvariant(case_data)
-            } else {
-                InvariantFuzzError::Revert(case_data)
-            });
-
-            return Ok(RichInvariantResults::new(false, None));
-        } else if call_result.reverted && !is_optimization && !invariant_config.has_delay() {
+            invariant_test.test_data.failures.revert_reason = Some(base.revert_reason.clone());
+
+            for (invariant, fail_on_revert) in failing_invariants {
+                let mut data = base.clone();
+                data.fail_on_revert = *fail_on_revert;
+                invariant_test.test_data.failures.record_failure(
+                    invariant,
+                    if is_assert_failure {
+                        InvariantFuzzError::BrokenInvariant(data)
+                    } else {
+                        InvariantFuzzError::Revert(data)
+                    },
+                );
+            }
+        }
+
+        if reverted && !is_optimization && !invariant_config.has_delay() {
             // If we don't fail test on revert then remove the reverted call from inputs.
             // Delay-enabled campaigns keep reverted calls so shrinking can preserve their
             // warp/roll contribution when building the final counterexample.
             invariant_run.inputs.pop();
         }
     }
-    Ok(RichInvariantResults::new(true, call_results))
+
+    Ok(invariant_test.test_data.failures.can_continue(invariant_contract.invariant_fns.len()))
 }
 
 /// Given the executor state, asserts conditions within `afterInvariant` function.
 /// If call fails then the invariant test is considered failed.
 pub(crate) fn assert_after_invariant<FEN: FoundryEvmNetwork>(
     invariant_contract: &InvariantContract<'_>,
-    invariant_test: &mut InvariantTest<FEN>,
+    invariant_test: &mut InvariantTest,
     invariant_run: &InvariantTestRun<FEN>,
     invariant_config: &InvariantConfig,
 ) -> Result<bool> {
@@ -279,13 +315,17 @@ pub(crate) fn assert_after_invariant<FEN: FoundryEvmNetwork>(
     if !success {
         let case_data = FailedInvariantCaseData::new(
             invariant_contract,
-            invariant_config,
+            invariant_config.shrink_run_limit,
+            invariant_config.fail_on_revert,
             &invariant_test.targeted_contracts,
             &invariant_run.inputs,
             call_result,
             &[],
         );
-        invariant_test.set_error(InvariantFuzzError::BrokenInvariant(case_data));
+        invariant_test.set_error(
+            invariant_contract.primary_invariant_fn,
+            InvariantFuzzError::BrokenInvariant(case_data),
+        );
     }
     Ok(success)
 }
diff --git a/crates/evm/evm/src/executors/invariant/shrink.rs b/crates/evm/evm/src/executors/invariant/shrink.rs
index 2096e5edc27f2..4c32bf425a606 100644
--- a/crates/evm/evm/src/executors/invariant/shrink.rs
+++ b/crates/evm/evm/src/executors/invariant/shrink.rs
@@ -5,6 +5,7 @@ use crate::executors::{
         result::did_fail_on_assert,
     },
 };
+use alloy_json_abi::Function;
 use alloy_primitives::{Address, Bytes, I256, U256};
 use foundry_config::InvariantConfig;
 use foundry_evm_core::{
@@ -44,11 +45,30 @@ impl CallSequenceShrinker {
 }
 
 /// Resets the progress bar for shrinking.
-fn reset_shrink_progress(config: &InvariantConfig, progress: Option<&ProgressBar>) {
+///
+/// Callers (e.g. `replay_error`) are responsible for invoking this before each shrink so the
+/// bar's length and message reflect the invariant currently being shrunk. Multi-invariant
+/// campaigns can call this once per invariant to display per-target progress.
+///
+/// `position` is `Some((current, total))` when more than one invariant needs shrinking in the
+/// same campaign; the bar then reads `[i/N] Shrink: <label>` so users can see how many
+/// shrinkers are left in the queue.
+pub(crate) fn reset_shrink_progress(
+    config: &InvariantConfig,
+    progress: Option<&ProgressBar>,
+    label: &str,
+    position: Option<(usize, usize)>,
+) {
     if let Some(progress) = progress {
         progress.set_length(config.shrink_run_limit as u64);
         progress.reset();
-        progress.set_message(" Shrink");
+        let message = match position {
+            Some((current, total)) if total > 1 => {
+                format!(" [{current}/{total}] Shrink: {label}")
+            }
+            _ => format!(" Shrink: {label}"),
+        };
+        progress.set_message(message);
     }
 }
 
@@ -121,9 +141,11 @@ fn build_shrunk_sequence(
     result
 }
 
+#[expect(clippy::too_many_arguments)]
 pub(crate) fn shrink_sequence<FEN: FoundryEvmNetwork>(
     config: &InvariantConfig,
     invariant_contract: &InvariantContract<'_>,
+    target_invariant: &Function,
     calls: &[BasicTxDetails],
     expect_assertion_failure: bool,
     executor: &Executor<FEN>,
@@ -132,10 +154,8 @@ pub(crate) fn shrink_sequence<FEN: FoundryEvmNetwork>(
 ) -> eyre::Result<Vec<BasicTxDetails>> {
     trace!(target: "forge::test", "Shrinking sequence of {} calls.", calls.len());
 
-    reset_shrink_progress(config, progress);
-
     let target_address = invariant_contract.address;
-    let calldata: Bytes = invariant_contract.invariant_function.selector().to_vec().into();
+    let calldata: Bytes = target_invariant.selector().to_vec().into();
     // Special case test: the invariant is *unsatisfiable* - it took 0 calls to
     // break the invariant -- consider emitting a warning.
     let (_, success) = call_invariant_function(executor, target_address, calldata.clone())?;
@@ -374,9 +394,11 @@ fn assertion_failure_reason<FEN: FoundryEvmNetwork>(
 /// Unlike `shrink_sequence` (for check mode), this function:
 /// - Accumulates warp/roll values from removed calls into the next kept call
 /// - Checks for target value equality rather than invariant failure
+#[expect(clippy::too_many_arguments)]
 pub(crate) fn shrink_sequence_value<FEN: FoundryEvmNetwork>(
     config: &InvariantConfig,
     invariant_contract: &InvariantContract<'_>,
+    target_invariant: &Function,
     calls: &[BasicTxDetails],
     executor: &Executor<FEN>,
     target_value: I256,
@@ -385,10 +407,8 @@ pub(crate) fn shrink_sequence_value<FEN: FoundryEvmNetwork>(
 ) -> eyre::Result<Vec<BasicTxDetails>> {
     trace!(target: "forge::test", "Shrinking optimization sequence of {} calls for target value {}.", calls.len(), target_value);
 
-    reset_shrink_progress(config, progress);
-
     let target_address = invariant_contract.address;
-    let calldata: Bytes = invariant_contract.invariant_function.selector().to_vec().into();
+    let calldata: Bytes = target_invariant.selector().to_vec().into();
 
     // Special case: check if target value is achieved with 0 calls.
     if check_sequence_value(executor.clone(), calls, vec![], target_address, calldata.clone())?
diff --git a/crates/evm/fuzz/src/invariant/mod.rs b/crates/evm/fuzz/src/invariant/mod.rs
index d23066061b6e0..350ad68e02f8e 100644
--- a/crates/evm/fuzz/src/invariant/mod.rs
+++ b/crates/evm/fuzz/src/invariant/mod.rs
@@ -267,7 +267,9 @@ pub struct InvariantContract<'a> {
     /// Name of the test contract.
     pub name: &'a str,
     /// Invariant function present in the test contract.
-    pub invariant_function: &'a Function,
+    pub primary_invariant_fn: &'a Function,
+    /// All invariant functions present in the test contract and their fail on revert config.
+    pub invariant_fns: Vec<(&'a Function, bool)>,
     /// If true, `afterInvariant` function is called after each invariant run.
     pub call_after_invariant: bool,
     /// ABI of the test contract.
@@ -279,16 +281,17 @@ impl<'a> InvariantContract<'a> {
     pub const fn new(
         address: Address,
         name: &'a str,
-        invariant_function: &'a Function,
+        primary_invariant_fn: &'a Function,
+        invariant_fns: Vec<(&'a Function, bool)>,
         call_after_invariant: bool,
         abi: &'a JsonAbi,
     ) -> Self {
-        Self { address, name, invariant_function, call_after_invariant, abi }
+        Self { address, name, primary_invariant_fn, invariant_fns, call_after_invariant, abi }
     }
 
     /// Returns true if this is an optimization mode invariant (returns int256).
     pub fn is_optimization(&self) -> bool {
-        is_optimization_invariant(self.invariant_function)
+        is_optimization_invariant(self.primary_invariant_fn)
     }
 }
 
diff --git a/crates/forge/src/result.rs b/crates/forge/src/result.rs
index 66be289ef252d..c8dfdeef60dd2 100644
--- a/crates/forge/src/result.rs
+++ b/crates/forge/src/result.rs
@@ -408,6 +408,23 @@ impl TestStatus {
     }
 }
 
+/// A non-primary invariant that broke during an `assert_all` campaign.
+///
+/// Carries everything needed to render the failure on its own (matching how the primary is
+/// displayed) and to point users at the persisted counterexample for re-running.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct InvariantSecondaryFailure {
+    /// Invariant function name (e.g. `invariant_cond3`).
+    pub name: String,
+    /// Revert reason or assertion failure message.
+    pub reason: String,
+    /// Counterexample sequence, when one is available.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub counterexample: Option<CounterExample>,
+    /// Path where the counterexample was persisted for re-running and shrinking.
+    pub persisted_path: std::path::PathBuf,
+}
+
 /// The result of an executed test.
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct TestResult {
@@ -421,6 +438,26 @@ pub struct TestResult {
     /// still be successful (i.e self.success == true) when it's expected to fail.
     pub reason: Option<String>,
 
+    /// Additional broken invariants beyond the primary (the one matched by `--mt`, or the only
+    /// one if no filter was applied).
+    ///
+    /// Each entry carries the invariant's name, the failure reason, an optional counterexample,
+    /// and the path where the counterexample has been persisted for shrinking on a subsequent run.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub invariant_secondary_failures: Vec<InvariantSecondaryFailure>,
+
+    /// Directory where invariant failure counterexamples have been persisted (set when one or more
+    /// secondary invariant failures were written, so users can locate persisted counterexamples).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub invariant_failure_dir: Option<std::path::PathBuf>,
+
+    /// Total number of invariants exercised in this `assert_all` run (primary + secondaries that
+    /// were not skipped by persisted-failure filtering). When `Some(n)` the test report renders
+    /// a `Suite assert_all: <broken>/<n> invariants broken` summary so users get an at-a-glance
+    /// health line without counting `[FAIL]` blocks. `None` for non-`assert_all` campaigns.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assert_all_invariant_count: Option<usize>,
+
     /// Minimal reproduction test case for failing test
     pub counterexample: Option<CounterExample>,
 
@@ -497,12 +534,21 @@ impl fmt::Display for TestResult {
                 s.yellow().fmt(f)
             }
             TestStatus::Failure => {
-                let mut s = String::from("[FAIL");
-                if self.reason.is_some() || self.counterexample.is_some() {
+                // Primary "broke" when we have a top-level reason or counterexample. Under
+                // `assert_all`, the test can fail purely via secondaries; in that case we
+                // skip the primary `[FAIL...]` header (would otherwise render hollow
+                // `[FAIL]`). For all other failure types (DS-style, plain unit, single
+                // invariant) we keep the original `[FAIL]`/`[FAIL: ...]` header.
+                let primary_broke = self.reason.is_some() || self.counterexample.is_some();
+                let render_primary_header = primary_broke
+                    || self.assert_all_invariant_count.is_none()
+                    || self.invariant_secondary_failures.is_empty();
+                let mut s = String::new();
+                if render_primary_header {
+                    s.push_str("[FAIL");
                     if let Some(reason) = &self.reason {
                         write!(s, ": {reason}").unwrap();
                     }
-
                     if let Some(counterexample) = &self.counterexample {
                         match counterexample {
                             CounterExample::Single(ex) => {
@@ -524,8 +570,55 @@ impl fmt::Display for TestResult {
                     } else {
                         s.push(']');
                     }
-                } else {
-                    s.push(']');
+                }
+                // Suite-level roll-up: when `assert_all` exercised more than one invariant in
+                // this campaign, print a single `Suite assert_all: <broken>/<total> invariants
+                // broken` line above the per-invariant blocks.
+                if let Some(total) = self.assert_all_invariant_count
+                    && total > 1
+                {
+                    let broken =
+                        usize::from(primary_broke) + self.invariant_secondary_failures.len();
+                    let prefix = if render_primary_header { "\n" } else { "" };
+                    writeln!(s, "{prefix}Suite assert_all: {broken}/{total} invariants broken")
+                        .unwrap();
+                }
+                if !self.invariant_secondary_failures.is_empty() {
+                    if self.assert_all_invariant_count.is_none() {
+                        writeln!(s).unwrap();
+                    }
+                    for failure in &self.invariant_secondary_failures {
+                        // If we have a (shrunk) counterexample, render the secondary the same
+                        // way the primary is rendered: `[FAIL: reason]\n\t[Sequence] ...`.
+                        // Otherwise fall back to the terse `name: reason` one-liner so the
+                        // structure is preserved for tools while keeping output compact.
+                        if let Some(CounterExample::Sequence(original, sequence)) =
+                            &failure.counterexample
+                        {
+                            writeln!(
+                                s,
+                                "[FAIL: {}] {}\n\t[Sequence] (original: {original}, shrunk: {})",
+                                failure.reason,
+                                failure.name,
+                                sequence.len()
+                            )
+                            .unwrap();
+                            for ex in sequence {
+                                writeln!(s, "{ex}").unwrap();
+                            }
+                        } else {
+                            writeln!(s, "{}: {}", failure.name, failure.reason).unwrap();
+                        }
+                    }
+                    if let Some(dir) = &self.invariant_failure_dir {
+                        writeln!(
+                            s,
+                            "{} invariant failures persisted to {} — rerun to shrink",
+                            self.invariant_secondary_failures.len(),
+                            dir.display()
+                        )
+                        .unwrap();
+                    }
                 }
                 s.red().wrap().fmt(f)
             }
@@ -730,6 +823,9 @@ impl TestResult {
         gas_report_traces: Vec<Vec<CallTraceArena>>,
         success: bool,
         reason: Option<String>,
+        invariant_secondary_failures: Vec<InvariantSecondaryFailure>,
+        invariant_failure_dir: Option<std::path::PathBuf>,
+        assert_all_invariant_count: Option<usize>,
         counterexample: Option<CounterExample>,
         cases: Vec<FuzzedCases>,
         reverts: usize,
@@ -752,6 +848,9 @@ impl TestResult {
             TestStatus::Failure
         };
         self.reason = reason;
+        self.invariant_secondary_failures = invariant_secondary_failures;
+        self.invariant_failure_dir = invariant_failure_dir;
+        self.assert_all_invariant_count = assert_all_invariant_count;
         self.counterexample = counterexample;
         self.gas_report_traces = gas_report_traces;
     }
diff --git a/crates/forge/src/runner.rs b/crates/forge/src/runner.rs
index d924c416759a2..6401dceb630ac 100644
--- a/crates/forge/src/runner.rs
+++ b/crates/forge/src/runner.rs
@@ -6,7 +6,7 @@ use crate::{
     fuzz::{BaseCounterExample, FuzzTestResult},
     multi_runner::{TestContract, TestRunnerConfig},
     progress::{TestsProgress, start_fuzz_progress},
-    result::{SuiteResult, TestResult, TestSetup},
+    result::{InvariantSecondaryFailure, SuiteResult, TestResult, TestSetup},
 };
 use alloy_dyn_abi::{DynSolValue, JsonAbiExt};
 use alloy_json_abi::Function;
@@ -29,7 +29,7 @@ use foundry_evm::{
     },
     fuzz::{
         BasicTxDetails, CallDetails, CounterExample, FuzzFixtures, fixture_name,
-        invariant::{InvariantContract, InvariantSettings},
+        invariant::{InvariantContract, InvariantSettings, is_optimization_invariant},
         strategies::EvmFuzzState,
     },
     revm::primitives::hardfork::SpecId,
@@ -345,7 +345,9 @@ impl<'a, FEN: FoundryEvmNetwork> ContractRunner<'a, FEN> {
 
         // Invariant testing requires tracing to figure out what contracts were created.
         // We also want to disable `debug` for setup since we won't be using those traces.
-        let has_invariants = self.contract.abi.functions().any(|func| func.is_invariant_test());
+        let invariant_fns: Vec<_> =
+            self.contract.abi.functions().filter(|func| func.is_invariant_test()).collect();
+        let has_invariants = !invariant_fns.is_empty();
 
         let prev_tracer = self.executor.inspector_mut().tracer.take();
         if prev_tracer.is_some() || has_invariants {
@@ -442,6 +444,7 @@ impl<'a, FEN: FoundryEvmNetwork> ContractRunner<'a, FEN> {
 
                 let mut res = FunctionRunner::new(&self, &setup).run(
                     func,
+                    invariant_fns.clone(),
                     kind,
                     call_after_invariant,
                     identified_contracts.as_ref(),
@@ -519,10 +522,22 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
     fn run(
         mut self,
         func: &Function,
+        invariants: Vec<&Function>,
         kind: TestFunctionKind,
         call_after_invariant: bool,
         identified_contracts: Option<&ContractsByAddress>,
     ) -> TestResult {
+        let fail_on_revert_for = |f: &Function| {
+            if self.inline_config.contains_function(self.cr.name, &f.name)
+                && let Ok(config) = self.cr.inline_config(Some(f))
+            {
+                return config.invariant.fail_on_revert;
+            }
+            self.config.invariant.fail_on_revert
+        };
+        let invariant_fns: Vec<_> =
+            invariants.into_iter().map(|f| (f, fail_on_revert_for(f))).collect();
+
         if let Err(e) = self.apply_function_inline_config(func) {
             self.result.single_fail(Some(e.to_string()));
             return self.result;
@@ -532,9 +547,12 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
             TestFunctionKind::UnitTest { .. } => self.run_unit_test(func),
             TestFunctionKind::FuzzTest { .. } => self.run_fuzz_test(func),
             TestFunctionKind::TableTest => self.run_table_test(func),
-            TestFunctionKind::InvariantTest => {
-                self.run_invariant_test(func, call_after_invariant, identified_contracts.unwrap())
-            }
+            TestFunctionKind::InvariantTest => self.run_invariant_test(
+                func,
+                invariant_fns,
+                call_after_invariant,
+                identified_contracts.unwrap(),
+            ),
             _ => unreachable!(),
         }
     }
@@ -713,6 +731,7 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
     fn run_invariant_test(
         mut self,
         func: &Function,
+        invariants: Vec<(&Function, bool)>,
         call_after_invariant: bool,
         identified_contracts: &ContractsByAddress,
     ) -> TestResult {
@@ -730,7 +749,8 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
         };
 
         let runner = self.invariant_runner();
-        let invariant_config = &self.config.invariant;
+        let invariant_config = self.config.invariant.clone();
+        let invariant_config = &invariant_config;
 
         let mut executor = self.clone_executor();
         // Enable edge coverage if running with coverage guided fuzzing or with edge coverage
@@ -759,24 +779,91 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
             identified_contracts,
             &self.cr.mcr.known_contracts,
         );
+        // Filter out additional invariants to test if we already have a persisted failure.
+        // Optimization mode only tracks the primary invariant's return value, so secondary
+        // boolean invariants are excluded to avoid silently skipping them.
+        let is_optimization = is_optimization_invariant(func);
+        // When the primary is an optimization invariant and the user has assert_all on, warn
+        // them once that secondary boolean invariants in the same contract are being skipped
+        // — assert_all has no effect under optimization mode, so silently dropping them would
+        // be a footgun.
+        if is_optimization && invariant_config.assert_all {
+            let dropped: Vec<&str> = invariants
+                .iter()
+                .filter(|(invariant_fn, _)| *invariant_fn != func)
+                .map(|(invariant_fn, _)| invariant_fn.name.as_str())
+                .collect();
+            if !dropped.is_empty() {
+                let _ = sh_warn!(
+                    "{}: assert_all is on but {} is an optimization invariant; \
+                     {} boolean invariant(s) skipped: {}. \
+                     Move them to a separate contract to run them.",
+                    self.cr.name,
+                    func.name,
+                    dropped.len(),
+                    dropped.join(", "),
+                );
+            }
+        }
+        // Compute current invariant settings up front so secondary persisted-failure handling
+        // can use the same compatibility check as the primary replay path below.
+        let current_settings = match evm.compute_settings(self.address) {
+            Ok(s) => s,
+            Err(e) => {
+                self.result.invariant_setup_fail(e);
+                return self.result;
+            }
+        };
+        // A secondary's persisted failure is only honored when its embedded settings still
+        // match the current run; stale caches fall back to a fresh campaign.
+        let secondary_has_compatible_persisted = |invariant_fn: &Function| {
+            persisted_call_sequence(
+                canonicalized(failure_dir.join(invariant_fn.name.clone())).as_path(),
+                &current_settings,
+            )
+            .is_some()
+        };
+        // Warn when secondaries are dropped because they already have persisted failures from a
+        // previous campaign. Symmetric with the primary's persisted-replay warning so users
+        // aren't surprised when fewer invariants appear in the report than their contract
+        // defines (Echidna/Medusa never skip properties between runs).
+        if !is_optimization && invariant_config.assert_all {
+            let persisted_skipped: Vec<&str> = invariants
+                .iter()
+                .filter(|(invariant_fn, _)| {
+                    *invariant_fn != func && secondary_has_compatible_persisted(invariant_fn)
+                })
+                .map(|(invariant_fn, _)| invariant_fn.name.as_str())
+                .collect();
+            if !persisted_skipped.is_empty() {
+                let _ = sh_warn!(
+                    "{}: {} invariant(s) skipped due to persisted failures: {}. \
+                     Run `forge clean` or delete files in {} to re-include.",
+                    self.cr.name,
+                    persisted_skipped.len(),
+                    persisted_skipped.join(", "),
+                    failure_dir.display(),
+                );
+            }
+        }
         let invariant_contract = InvariantContract::new(
             self.address,
             self.cr.name,
             func,
+            invariants
+                .into_iter()
+                .filter(|(invariant_fn, _)| {
+                    *invariant_fn == func
+                        || (!is_optimization
+                            && invariant_config.assert_all
+                            && !secondary_has_compatible_persisted(invariant_fn))
+                })
+                .collect(),
             call_after_invariant,
             &self.cr.contract.abi,
         );
         let show_solidity = invariant_config.show_solidity;
 
-        // Compute current invariant settings for failure validation.
-        let current_settings = match evm.compute_settings(self.address) {
-            Ok(s) => s,
-            Err(e) => {
-                self.result.invariant_setup_fail(e);
-                return self.result;
-            }
-        };
-
         let progress = start_fuzz_progress(
             self.cr.progress,
             self.cr.name,
@@ -810,7 +897,7 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
                 &txes,
                 (0..min(txes.len(), invariant_config.depth as usize)).collect(),
                 invariant_contract.address,
-                invariant_contract.invariant_function.selector().to_vec().into(),
+                invariant_contract.primary_invariant_fn.selector().to_vec().into(),
                 CheckSequenceOptions {
                     accumulate_warp_roll: invariant_config.has_delay(),
                     fail_on_revert: invariant_config.fail_on_revert,
@@ -841,6 +928,7 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
                     assertion_failure,
                     None, // check mode
                     &invariant_contract,
+                    invariant_contract.primary_invariant_fn,
                     &self.cr.mcr.known_contracts,
                     identified_contracts.clone(),
                     &mut self.result.logs,
@@ -849,6 +937,7 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
                     &mut self.result.deprecated_cheatcodes,
                     progress.as_ref(),
                     &self.tcfg.early_exit,
+                    None, // single-invariant replay path; no [i/N] counter
                 ) {
                     Ok(replayed_call_sequence) if !replayed_call_sequence.is_empty() => {
                         call_sequence = replayed_call_sequence;
@@ -869,7 +958,7 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
 
                 self.result.invariant_replay_fail(
                     replayed_entirely,
-                    &invariant_contract.invariant_function.name,
+                    &invariant_contract.primary_invariant_fn.name,
                     replay_reason,
                     call_sequence,
                 );
@@ -894,125 +983,239 @@ impl<'a, FEN: FoundryEvmNetwork> FunctionRunner<'a, FEN> {
         self.result.merge_coverages(invariant_result.line_coverage);
 
         let mut counterexample = None;
-        let success = invariant_result.error.is_none();
-        let reason = invariant_result.error.as_ref().and_then(|err| err.revert_reason());
-
-        match invariant_result.error {
-            // If invariants were broken, replay the error to collect logs and traces
-            Some(error) => match error {
-                InvariantFuzzError::BrokenInvariant(case_data)
-                | InvariantFuzzError::Revert(case_data) => {
-                    // Replay error to create counterexample and to collect logs, traces and
-                    // coverage.
-                    match case_data.test_error {
-                        TestError::Abort(_) => {}
-                        TestError::Fail(_, ref calls) => {
-                            match replay_error(
-                                evm.config(),
-                                self.clone_executor(),
-                                calls,
-                                Some(case_data.inner_sequence),
-                                case_data.assertion_failure,
-                                None, // check mode
-                                &invariant_contract,
-                                &self.cr.mcr.known_contracts,
-                                identified_contracts.clone(),
-                                &mut self.result.logs,
-                                &mut self.result.traces,
-                                &mut self.result.line_coverage,
-                                &mut self.result.deprecated_cheatcodes,
-                                progress.as_ref(),
-                                &self.tcfg.early_exit,
-                            ) {
-                                Ok(call_sequence) if !call_sequence.is_empty() => {
-                                    // Persist error in invariant failure dir.
-                                    record_invariant_failure(
-                                        failure_dir.as_path(),
-                                        failure_file.as_path(),
-                                        &call_sequence,
-                                        &current_settings,
-                                        case_data.assertion_failure,
-                                    );
-
-                                    let original_seq_len =
-                                        if let TestError::Fail(_, calls) = &case_data.test_error {
-                                            calls.len()
-                                        } else {
-                                            call_sequence.len()
-                                        };
-
-                                    counterexample = Some(CounterExample::Sequence(
-                                        original_seq_len,
-                                        call_sequence,
-                                    ))
-                                }
-                                Ok(_) => {}
-                                Err(err) => {
-                                    error!(%err, "Failed to replay invariant error");
-                                }
-                            }
-                        }
-                    };
+        let success = invariant_result.errors.is_empty();
+        let reason = invariant_result
+            .errors
+            .get(&invariant_contract.primary_invariant_fn.name)
+            .and_then(|err| err.revert_reason());
+        let mut invariant_secondary_failures = vec![];
+        let mut any_secondary_persisted = false;
+
+        if success {
+            if let Some(best_value) = invariant_result.optimization_best_value {
+                // Optimization mode: replay and shrink to find shortest best sequence.
+                match replay_error(
+                    evm.config(),
+                    self.clone_executor(),
+                    &invariant_result.optimization_best_sequence,
+                    None,
+                    false,
+                    Some(best_value),
+                    &invariant_contract,
+                    invariant_contract.primary_invariant_fn,
+                    &self.cr.mcr.known_contracts,
+                    identified_contracts.clone(),
+                    &mut self.result.logs,
+                    &mut self.result.traces,
+                    &mut self.result.line_coverage,
+                    &mut self.result.deprecated_cheatcodes,
+                    progress.as_ref(),
+                    &self.tcfg.early_exit,
+                    None, // optimization mode is single-invariant; no [i/N] counter
+                ) {
+                    Ok(best_sequence) if !best_sequence.is_empty() => {
+                        counterexample = Some(CounterExample::Sequence(
+                            invariant_result.optimization_best_sequence.len(),
+                            best_sequence,
+                        ));
+                    }
+                    Err(err) => {
+                        error!(%err, "Failed to replay optimization best sequence");
+                    }
+                    _ => {}
                 }
-                InvariantFuzzError::MaxAssumeRejects(_) => {}
-            },
+            } else {
+                // Standard check mode: replay last run for traces.
+                if let Err(err) = replay_run(
+                    &invariant_contract,
+                    invariant_contract.primary_invariant_fn,
+                    self.clone_executor(),
+                    &self.cr.mcr.known_contracts,
+                    identified_contracts.clone(),
+                    &mut self.result.logs,
+                    &mut self.result.traces,
+                    &mut self.result.line_coverage,
+                    &mut self.result.deprecated_cheatcodes,
+                    &invariant_result.last_run_inputs,
+                    show_solidity,
+                ) {
+                    error!(%err, "Failed to replay last invariant run");
+                }
+            }
+        } else {
+            // Total broken invariants in this campaign — used to decorate the shrink progress
+            // bar with `[i/N]` so users see how many shrinkers are queued behind the current
+            // one. `errors` keys cover both the primary and any broken secondaries.
+            let total_broken = invariant_result.errors.len();
+            // Check if primary invariant was broken and replay error.
+            if let Some(error) =
+                invariant_result.errors.get(&invariant_contract.primary_invariant_fn.name)
+                && let InvariantFuzzError::BrokenInvariant(case_data)
+                | InvariantFuzzError::Revert(case_data) = error
+                && let TestError::Fail(_, ref calls) = case_data.test_error
+            {
+                match replay_error(
+                    evm.config(),
+                    self.clone_executor(),
+                    calls,
+                    Some(case_data.inner_sequence.clone()),
+                    case_data.assertion_failure,
+                    None, // check mode
+                    &invariant_contract,
+                    invariant_contract.primary_invariant_fn,
+                    &self.cr.mcr.known_contracts,
+                    identified_contracts.clone(),
+                    &mut self.result.logs,
+                    &mut self.result.traces,
+                    &mut self.result.line_coverage,
+                    &mut self.result.deprecated_cheatcodes,
+                    progress.as_ref(),
+                    &self.tcfg.early_exit,
+                    Some((1, total_broken)),
+                ) {
+                    Ok(call_sequence) if !call_sequence.is_empty() => {
+                        // Persist error in invariant failure dir.
+                        record_invariant_failure(
+                            failure_dir.as_path(),
+                            failure_file.as_path(),
+                            &call_sequence,
+                            &current_settings,
+                            case_data.assertion_failure,
+                        );
 
-            // If invariants ran successfully, replay the last run to collect logs and traces.
-            _ => {
-                if let Some(best_value) = invariant_result.optimization_best_value {
-                    // Optimization mode: replay and shrink to find shortest best sequence.
-                    match replay_error(
-                        evm.config(),
-                        self.clone_executor(),
-                        &invariant_result.optimization_best_sequence,
-                        None,
-                        false,
-                        Some(best_value),
-                        &invariant_contract,
-                        &self.cr.mcr.known_contracts,
-                        identified_contracts.clone(),
-                        &mut self.result.logs,
-                        &mut self.result.traces,
-                        &mut self.result.line_coverage,
-                        &mut self.result.deprecated_cheatcodes,
-                        progress.as_ref(),
-                        &self.tcfg.early_exit,
-                    ) {
-                        Ok(best_sequence) if !best_sequence.is_empty() => {
-                            counterexample = Some(CounterExample::Sequence(
-                                invariant_result.optimization_best_sequence.len(),
-                                best_sequence,
-                            ));
-                        }
-                        Err(err) => {
-                            error!(%err, "Failed to replay optimization best sequence");
-                        }
-                        _ => {}
+                        let original_seq_len =
+                            if let TestError::Fail(_, calls) = &case_data.test_error {
+                                calls.len()
+                            } else {
+                                call_sequence.len()
+                            };
+
+                        counterexample =
+                            Some(CounterExample::Sequence(original_seq_len, call_sequence))
                     }
-                } else {
-                    // Standard check mode: replay last run for traces.
-                    if let Err(err) = replay_run(
-                        &invariant_contract,
-                        self.clone_executor(),
-                        &self.cr.mcr.known_contracts,
-                        identified_contracts.clone(),
-                        &mut self.result.logs,
-                        &mut self.result.traces,
-                        &mut self.result.line_coverage,
-                        &mut self.result.deprecated_cheatcodes,
-                        &invariant_result.last_run_inputs,
-                        show_solidity,
-                    ) {
-                        error!(%err, "Failed to replay last invariant run");
+                    Ok(_) => {}
+                    Err(err) => {
+                        error!(%err, "Failed to replay invariant error");
                     }
                 }
             }
+
+            // Shrink each broken non-primary invariant in turn so users get a ready-to-debug
+            // counterexample for every failure in a single run. Loop is serial; on Ctrl+C we
+            // still record every known secondary failure (without shrinking or persisting), so
+            // the final report matches what the live progress bar showed.
+            //
+            // `next_position` tracks where this invariant sits in the broken queue (primary is
+            // 1, secondaries follow). Only incremented when a secondary is actually shrunk so
+            // the bar's `[i/N]` counter matches user-visible progress.
+            let mut next_position = 2usize;
+            for (invariant, _) in &invariant_contract.invariant_fns {
+                if invariant.name == invariant_contract.primary_invariant_fn.name {
+                    continue;
+                }
+
+                // Skip invariants whose counterexample is already persisted from a prior run
+                // (those were filtered out of the live campaign earlier; `errors` won't contain
+                // them, but the dir check is a belt-and-braces safety net). Use the same
+                // settings-aware compatibility check as the filter so a stale persisted cache
+                // doesn't suppress a freshly-broken secondary.
+                let persisted_failure = canonicalized(failure_dir.join(invariant.name.clone()));
+                if !secondary_has_compatible_persisted(invariant)
+                    && let Some(error) = invariant_result.errors.get(&invariant.name)
+                    && let InvariantFuzzError::BrokenInvariant(case_data)
+                    | InvariantFuzzError::Revert(case_data) = error
+                    && let TestError::Fail(_, ref calls) = case_data.test_error
+                {
+                    let original_seq_len = calls.len();
+                    // On Ctrl+C: skip the (potentially long) replay+shrink, but still persist
+                    // the un-shrunk sequence so the next run targeting this invariant picks it
+                    // up and shrinks from the saved counterexample. The current run's output
+                    // still gets a terse `name: reason` line via the no-counterexample path.
+                    let secondary_counterexample = if self.tcfg.early_exit.should_stop() {
+                        let unshrunk_sequence = calls
+                            .iter()
+                            .map(|tx| {
+                                BaseCounterExample::from_invariant_call(
+                                    tx,
+                                    identified_contracts,
+                                    None,
+                                    invariant_config.show_solidity,
+                                )
+                            })
+                            .collect::<Vec<_>>();
+                        record_invariant_failure(
+                            failure_dir.as_path(),
+                            persisted_failure.as_path(),
+                            &unshrunk_sequence,
+                            &current_settings,
+                            case_data.assertion_failure,
+                        );
+                        any_secondary_persisted = true;
+                        None
+                    } else {
+                        let position = next_position;
+                        next_position += 1;
+                        match replay_error(
+                            invariant_config.clone(),
+                            self.clone_executor(),
+                            calls,
+                            Some(case_data.inner_sequence.clone()),
+                            case_data.assertion_failure,
+                            None, // check mode
+                            &invariant_contract,
+                            invariant,
+                            &self.cr.mcr.known_contracts,
+                            identified_contracts.clone(),
+                            &mut self.result.logs,
+                            &mut self.result.traces,
+                            &mut self.result.line_coverage,
+                            &mut self.result.deprecated_cheatcodes,
+                            progress.as_ref(),
+                            &self.tcfg.early_exit,
+                            Some((position, total_broken)),
+                        ) {
+                            Ok(call_sequence) if !call_sequence.is_empty() => {
+                                record_invariant_failure(
+                                    failure_dir.as_path(),
+                                    persisted_failure.as_path(),
+                                    &call_sequence,
+                                    &current_settings,
+                                    case_data.assertion_failure,
+                                );
+                                any_secondary_persisted = true;
+                                Some(CounterExample::Sequence(original_seq_len, call_sequence))
+                            }
+                            Ok(_) => None,
+                            Err(err) => {
+                                error!(%err, "Failed to replay invariant error");
+                                None
+                            }
+                        }
+                    };
+                    invariant_secondary_failures.push(InvariantSecondaryFailure {
+                        name: invariant.name.clone(),
+                        reason: error.revert_reason().unwrap_or_default(),
+                        counterexample: secondary_counterexample,
+                        persisted_path: persisted_failure.clone(),
+                    });
+                }
+            }
         }
 
+        let invariant_failure_dir = any_secondary_persisted.then(|| failure_dir.clone());
+        // Only attach a suite-level roll-up when `assert_all` actually exercised >1 invariant.
+        // Single-invariant runs (no assert_all, or filter-narrowed to one) get the legacy
+        // single-block render with no roll-up line.
+        let assert_all_invariant_count = (invariant_config.assert_all
+            && invariant_contract.invariant_fns.len() > 1)
+            .then_some(invariant_contract.invariant_fns.len());
         self.result.invariant_result(
             invariant_result.gas_report_traces,
             success,
             reason,
+            invariant_secondary_failures,
+            invariant_failure_dir,
+            assert_all_invariant_count,
             counterexample,
             invariant_result.cases,
             invariant_result.reverts,
diff --git a/crates/forge/tests/cli/config.rs b/crates/forge/tests/cli/config.rs
index dca88ad1c2f63..9ce9983863ab3 100644
--- a/crates/forge/tests/cli/config.rs
+++ b/crates/forge/tests/cli/config.rs
@@ -225,6 +225,7 @@ failure_persist_dir = "cache/invariant"
 show_metrics = true
 show_solidity = false
 check_interval = 1
+assert_all = true
 
 [labels]
 
@@ -1318,7 +1319,8 @@ forgetest_init!(test_default_config, |prj, cmd| {
     "show_solidity": false,
     "max_time_delay": null,
     "max_block_delay": null,
-    "check_interval": 1
+    "check_interval": 1,
+    "assert_all": true
   },
   "ffi": false,
   "live_logs": false,
diff --git a/crates/forge/tests/cli/test_cmd/invariant/common.rs b/crates/forge/tests/cli/test_cmd/invariant/common.rs
index fefd95def0412..6f413b152e9dc 100644
--- a/crates/forge/tests/cli/test_cmd/invariant/common.rs
+++ b/crates/forge/tests/cli/test_cmd/invariant/common.rs
@@ -3,6 +3,12 @@ use super::*;
 forgetest!(invariant_after_invariant, |prj, cmd| {
     prj.insert_vm();
     prj.insert_ds_test();
+    // This test exercises `afterInvariant` semantics in isolation; disable `assert_all` so the
+    // campaign aborts on the first broken invariant per function (legacy behavior) instead of
+    // fanning out across all invariants in the suite.
+    prj.update_config(|config| {
+        config.invariant.assert_all = false;
+    });
 
     prj.add_test(
         "InvariantAfterInvariant.t.sol",
@@ -2063,8 +2069,11 @@ Ran 1 test for test/InvariantReplayKeepsAfterInvariantAssertion.t.sol:InvariantR
 });
 
 forgetest_init!(invariant_test1, |prj, cmd| {
+    // Disable `assert_all` so each invariant in the suite reports independently without secondary
+    // failures being attached to the other (the two invariants here share the same condition).
     prj.update_config(|config| {
         config.invariant.depth = 10;
+        config.invariant.assert_all = false;
     });
 
     prj.add_test(
@@ -2147,11 +2156,14 @@ Tip: Run `forge test --rerun` to retry only the 2 failed tests
 });
 
 forgetest_init!(invariant_warp_and_roll, |prj, cmd| {
+    // Disable `assert_all` so `--mt invariant_warp` only exercises invariant_warp, isolating the
+    // warp/roll behavior under test from invariant_roll fan-out.
     prj.update_config(|config| {
         config.fuzz.seed = Some(U256::from(119u32));
         config.invariant.max_time_delay = Some(604800);
         config.invariant.max_block_delay = Some(60480);
         config.invariant.shrink_run_limit = 0;
+        config.invariant.assert_all = false;
     });
 
     prj.add_test(
diff --git a/crates/forge/tests/cli/test_cmd/invariant/mod.rs b/crates/forge/tests/cli/test_cmd/invariant/mod.rs
index 723b5bd789c8b..aa64158da2a04 100644
--- a/crates/forge/tests/cli/test_cmd/invariant/mod.rs
+++ b/crates/forge/tests/cli/test_cmd/invariant/mod.rs
@@ -1317,3 +1317,537 @@ contract CheckIntervalInlineTest is Test {
 "#
     ]]);
 });
+
+forgetest_init!(assert_all, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 10;
+        config.invariant.depth = 100;
+        config.invariant.assert_all = true;
+    });
+    prj.add_source(
+        "Counter.sol",
+        r#"
+contract Counter {
+    uint256 public cond;
+
+    function work(uint256 x) public {
+        if (x % 2 != 0 && x < 9000) {
+            cond++;
+        } else {
+            revert();
+        }
+    }
+}
+   "#,
+    );
+    prj.add_test(
+        "CounterTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {Counter} from "../src/Counter.sol";
+
+contract CounterTest is Test {
+    Counter public counter;
+
+    function setUp() public {
+        counter = new Counter();
+    }
+
+    function invariant_cond1() public view {
+        require(counter.cond() < 10, "condition 1 met");
+    }
+
+    function invariant_cond2() public view {
+        require(counter.cond() < 15, "condition 2 met");
+    }
+
+    function invariant_cond3() public view {
+        require(counter.cond() < 5, "condition 3 met");
+    }
+
+    function invariant_cond4() public view {
+        require(counter.cond() < 111111, "condition 4 met");
+    }
+
+    /// forge-config: default.invariant.fail-on-revert = true
+    function invariant_cond5() public view {
+        require(counter.cond() < 111111, "condition 5 met");
+    }
+}
+   "#,
+    );
+
+    // Check that running single `invariant_cond3` test continue to run until it breaks all other
+    // invariants.
+    cmd.args(["test", "--mt", "invariant_cond3"]).assert_failure().stdout_eq(str![[r#"
+[COMPILING_FILES] with [SOLC_VERSION]
+[SOLC_VERSION] [ELAPSED]
+Compiler run successful!
+
+Ran 1 test for test/CounterTest.t.sol:CounterTest
+[FAIL: condition 3 met]
+	[Sequence] (original: 5, shrunk: 5)
+...
+
+Suite assert_all: 4/5 invariants broken
+[FAIL: condition 1 met] invariant_cond1
+	[Sequence] (original: [..], shrunk: [..])
+...
+[FAIL: condition 2 met] invariant_cond2
+	[Sequence] (original: [..], shrunk: [..])
+...
+[FAIL: EvmError: Revert] invariant_cond5
+	[Sequence] (original: [..], shrunk: [..])
+...
+3 invariant failures persisted to cache/invariant/failures/CounterTest — rerun to shrink
+...
+
+"#]]);
+
+    // Re-running the same target replays cond3's persisted counterexample and exits without
+    // running a fresh campaign — only the primary block, no secondary [FAIL]s, no
+    // persisted-failures footer, no `Suite assert_all` roll-up. A stderr warning calls out
+    // the three secondaries that were skipped because they already have persisted failures
+    // (cond1, cond2, cond5) so users aren't surprised they're missing from the report.
+    cmd.forge_fuse()
+        .args(["test", "--mt", "invariant_cond3"])
+        .assert_failure()
+        .stderr_eq(str![[r#"
+Warning: test/CounterTest.t.sol:CounterTest: 3 invariant(s) skipped due to persisted failures: invariant_cond1, invariant_cond2, invariant_cond5. Run `forge clean` or delete files in [..]/cache/invariant/failures/CounterTest to re-include.
+...
+"#]])
+        .stdout_eq(str![[r#"
+No files changed, compilation skipped
+...
+Ran 1 test for test/CounterTest.t.sol:CounterTest
+[FAIL: condition 3 met]
+	[Sequence] (original: 5, shrunk: 5)
+...
+ invariant_cond3() (runs: 1, calls: 1, reverts: [..])
+...
+"#]]);
+});
+
+// Verifies that when `assert_all` is on but only the primary invariant breaks, the secondary
+// path stays empty: no `[FAIL: ...] <name>` blocks for the passing invariants and no
+// persisted-failures footer.
+forgetest_init!(assert_all_only_primary, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 5;
+        config.invariant.depth = 50;
+        config.invariant.assert_all = true;
+    });
+    prj.add_source(
+        "Counter.sol",
+        r#"
+contract Counter {
+    uint256 public cond;
+
+    function inc() public {
+        cond++;
+    }
+}
+   "#,
+    );
+    prj.add_test(
+        "CounterTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {Counter} from "../src/Counter.sol";
+
+contract CounterTest is Test {
+    Counter public counter;
+
+    function setUp() public {
+        counter = new Counter();
+    }
+
+    function invariant_breakable() public view {
+        require(counter.cond() < 3, "primary broken");
+    }
+
+    function invariant_safe() public view {
+        require(counter.cond() < 1000000, "should never break");
+    }
+}
+   "#,
+    );
+
+    // Only the primary breaks: a single [FAIL] block, the suite roll-up shows 1/2, and the
+    // never-broken `invariant_safe` produces no output.
+    cmd.args(["test", "--mt", "invariant_breakable"]).assert_failure().stdout_eq(str![[r#"
+...
+Ran 1 test for test/CounterTest.t.sol:CounterTest
+[FAIL: primary broken]
+	[Sequence] (original: [..], shrunk: [..])
+...
+
+Suite assert_all: 1/2 invariants broken
+...
+ invariant_breakable() (runs: [..], calls: [..], reverts: [..])
+...
+"#]]);
+});
+
+// Under `assert_all` + `fail_on_revert = false`, a handler `assert(false)` must still
+// fail the campaign and be attributed to every live invariant.
+forgetest_init!(assert_all_assertion_failure_breaks_all_live_invariants, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 1;
+        config.invariant.depth = 10;
+        config.invariant.fail_on_revert = false;
+        config.invariant.assert_all = true;
+    });
+    prj.add_source(
+        "AssertHandler.sol",
+        r#"
+contract AssertHandler {
+    uint256 public calls;
+
+    function alwaysAssert() external {
+        calls++;
+        assert(false);
+    }
+}
+   "#,
+    );
+    prj.add_test(
+        "AssertAllAssertTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {AssertHandler} from "../src/AssertHandler.sol";
+
+contract AssertAllAssertTest is Test {
+    AssertHandler handler;
+
+    function setUp() public {
+        handler = new AssertHandler();
+        targetContract(address(handler));
+    }
+
+    function invariant_a() public view {}
+
+    function invariant_b() public view {}
+}
+   "#,
+    );
+
+    cmd.args(["test", "--mt", "invariant_a"]).assert_failure().stdout_eq(str![[r#"
+...
+Ran 1 test for test/AssertAllAssertTest.t.sol:AssertAllAssertTest
+[FAIL: panic: assertion failed (0x01)]
+	[Sequence] (original: [..], shrunk: [..])
+...
+
+Suite assert_all: 2/2 invariants broken
+[FAIL: panic: assertion failed (0x01)] invariant_b
+	[Sequence] (original: [..], shrunk: [..])
+...
+"#]]);
+});
+
+// Verifies the startup warning fired by `assert_all + optimization mode`: when the primary
+// invariant returns int256 (optimization target) the campaign loop can't also evaluate boolean
+// invariants, so they are silently dropped. Without the warning users wouldn't realize their
+// other `invariant_*` properties never ran.
+forgetest_init!(assert_all_optimization_mode_warning, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 1;
+        config.invariant.depth = 5;
+        // assert_all defaults to true post-rename, but make it explicit for the test's intent.
+        config.invariant.assert_all = true;
+    });
+    prj.add_source(
+        "OptHandler.sol",
+        r#"
+contract OptHandler {
+    uint256 public x;
+    function bump(uint256 v) public { x += v % 100; }
+}
+   "#,
+    );
+    prj.add_test(
+        "OptTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {OptHandler} from "../src/OptHandler.sol";
+
+contract OptTest is Test {
+    OptHandler h;
+    function setUp() public { h = new OptHandler(); targetContract(address(h)); }
+
+    /// @notice Optimization invariant — primary maximizes int256.
+    function invariant_maximize() public view returns (int256) {
+        return int256(h.x());
+    }
+
+    function invariant_boolean_one() public view {
+        require(h.x() < 1000000, "should not exceed 1M");
+    }
+
+    function invariant_boolean_two() public view {
+        require(h.x() != 42, "magic value not allowed");
+    }
+}
+   "#,
+    );
+
+    cmd.args(["test", "--mt", "invariant_maximize"])
+        .assert_success()
+        .stderr_eq(str![[r#"
+...
+Warning: test/OptTest.t.sol:OptTest: assert_all is on but invariant_maximize is an optimization invariant; 2 boolean invariant(s) skipped: invariant_boolean_one, invariant_boolean_two. Move them to a separate contract to run them.
+...
+"#]])
+        .stdout_eq(str![[r#"
+...
+[PASS]
+	[Best sequence] [..]
+...
+ invariant_maximize() (best: [..], runs: 1, calls: 5)
+...
+"#]]);
+});
+
+// Verifies that under `assert_all` the `afterInvariant` hook keeps running on later runs even
+// after an earlier invariant has already broken.
+forgetest_init!(assert_all_after_invariant_runs_after_earlier_failure, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 5;
+        config.invariant.depth = 20;
+        config.invariant.assert_all = true;
+    });
+    prj.add_source(
+        "Counter.sol",
+        r#"
+contract Counter {
+    uint256 public cond;
+
+    function inc() public {
+        cond++;
+    }
+}
+   "#,
+    );
+    prj.add_test(
+        "AfterInvariantTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {Counter} from "../src/Counter.sol";
+
+contract AfterInvariantTest is Test {
+    Counter public counter;
+
+    function setUp() public {
+        counter = new Counter();
+        targetContract(address(counter));
+    }
+
+    // Breaks early in run 1.
+    function invariant_first() public view {
+        require(counter.cond() < 2, "first broken");
+    }
+
+    // Never breaks; keeps the campaign alive past run 1.
+    function invariant_second() public view {
+        require(counter.cond() < 1000000, "second broken");
+    }
+
+    // Always reverts; only reached on later runs if the hook isn't gated campaign-wide.
+    function afterInvariant() public pure {
+        require(false, "after_invariant_marker");
+    }
+}
+   "#,
+    );
+
+    cmd.args(["test", "--mt", "invariant_first"]).assert_failure().stdout_eq(str![[r#"
+...
+[FAIL: after_invariant_marker]
+...
+"#]]);
+});
+
+// Verifies a stale persisted secondary failure (settings have changed since it was written) is
+// not silently dropped from an `assert_all` campaign — the secondary is re-evaluated instead.
+forgetest_init!(assert_all_secondary_persisted_revalidates_on_settings_change, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 5;
+        config.invariant.depth = 50;
+        config.invariant.assert_all = true;
+        config.invariant.fail_on_revert = false;
+    });
+    prj.add_source(
+        "Counter.sol",
+        r#"
+contract Counter {
+    uint256 public cond;
+
+    function inc() public {
+        cond++;
+    }
+}
+   "#,
+    );
+    prj.add_test(
+        "StaleSecondaryTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {Counter} from "../src/Counter.sol";
+
+contract StaleSecondaryTest is Test {
+    Counter public counter;
+
+    function setUp() public {
+        counter = new Counter();
+        targetContract(address(counter));
+    }
+
+    function invariant_first() public view {
+        require(counter.cond() < 2, "first broken");
+    }
+
+    function invariant_second() public view {
+        require(counter.cond() < 3, "second broken");
+    }
+}
+   "#,
+    );
+
+    // First run: both invariants break and persist their counterexamples under the current
+    // settings (fail_on_revert = false).
+    cmd.args(["test", "--mt", "invariant_first"]).assert_failure();
+
+    // Flip a tracked InvariantSettings field so the persisted secondary cache is now stale.
+    prj.update_config(|config| {
+        config.invariant.fail_on_revert = true;
+    });
+
+    // Re-run targeting the same primary. With the fix, the stale secondary cache is rejected
+    // and `invariant_second` is re-evaluated — the suite roll-up shows 2/2 broken. With the
+    // bug, the bare `.exists()` check filtered the secondary out and only the primary block
+    // would render (no roll-up).
+    cmd.forge_fuse().args(["test", "--mt", "invariant_first"]).assert_failure().stdout_eq(str![[
+        r#"
+...
+Suite assert_all: 2/2 invariants broken
+...
+"#
+    ]]);
+});
+
+// Verifies that when the selected primary invariant passes but a secondary fails under
+// `assert_all`, the report doesn't render a hollow `[FAIL]` header for the primary and the
+// suite roll-up counts only the actually-broken invariants.
+forgetest_init!(assert_all_secondary_only_failure_no_hollow_fail, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 5;
+        config.invariant.depth = 50;
+        config.invariant.assert_all = true;
+    });
+    prj.add_source(
+        "Counter.sol",
+        r#"
+contract Counter {
+    uint256 public cond;
+
+    function inc() public {
+        cond++;
+    }
+}
+   "#,
+    );
+    prj.add_test(
+        "SecondaryOnlyTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {Counter} from "../src/Counter.sol";
+
+contract SecondaryOnlyTest is Test {
+    Counter public counter;
+
+    function setUp() public {
+        counter = new Counter();
+        targetContract(address(counter));
+    }
+
+    // Selected primary; never breaks.
+    function invariant_safe() public view {
+        require(counter.cond() < 1000000, "safe broken");
+    }
+
+    // Secondary; breaks within the first run.
+    function invariant_breakable() public view {
+        require(counter.cond() < 2, "breakable broken");
+    }
+}
+   "#,
+    );
+
+    cmd.args(["test", "--mt", "invariant_safe"]).assert_failure().stdout_eq(str![[r#"
+...
+Suite assert_all: 1/2 invariants broken
+[FAIL: breakable broken] invariant_breakable
+...
+"#]]);
+});
+
+// Verifies the structured JSON failure event emitted at campaign end attributes the broken
+// invariant in declaration order (deterministic) instead of using arbitrary HashMap iteration.
+forgetest_init!(assert_all_failure_event_uses_declaration_order, |prj, cmd| {
+    prj.update_config(|config| {
+        config.invariant.runs = 1;
+        config.invariant.depth = 5;
+        config.invariant.assert_all = true;
+    });
+    prj.add_source(
+        "Counter.sol",
+        r#"
+contract Counter {
+    uint256 public cond;
+
+    function inc() public {
+        cond++;
+    }
+}
+   "#,
+    );
+    prj.add_test(
+        "FailureEventTest.t.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+import {Counter} from "../src/Counter.sol";
+
+contract FailureEventTest is Test {
+    Counter public counter;
+
+    function setUp() public {
+        counter = new Counter();
+        targetContract(address(counter));
+    }
+
+    // Declaration-order: a, b, c. All break on the same call.
+    function invariant_a() public view {
+        require(counter.cond() < 1, "a broken");
+    }
+
+    function invariant_b() public view {
+        require(counter.cond() < 1, "b broken");
+    }
+
+    function invariant_c() public view {
+        require(counter.cond() < 1, "c broken");
+    }
+}
+   "#,
+    );
+
+    // Primary is `invariant_c`, but the failure event must name `invariant_a` (first declared
+    // broken invariant) with its matching reason — not whichever entry HashMap iteration
+    // surfaces.
+    cmd.args(["test", "--mt", "invariant_c"]).assert_failure().stderr_eq(str![[r#"
+...
+{"timestamp":[..],"event":"failure","invariant":"invariant_a","target":"test/FailureEventTest.t.sol:FailureEventTest","reason":"a broken"}
+...
+"#]]);
+});
diff --git a/crates/forge/tests/cli/test_cmd/invariant/target.rs b/crates/forge/tests/cli/test_cmd/invariant/target.rs
index a2b766926bb09..5f7cf7f011007 100644
--- a/crates/forge/tests/cli/test_cmd/invariant/target.rs
+++ b/crates/forge/tests/cli/test_cmd/invariant/target.rs
@@ -3,9 +3,12 @@ use super::*;
 forgetest!(filters, |prj, cmd| {
     prj.insert_vm();
     prj.insert_ds_test();
+    // Disable `assert_all` so this test exercises target-filter semantics without secondary
+    // invariants in the same suite being reported alongside the filtered target.
     prj.update_config(|config| {
         config.invariant.runs = 50;
         config.invariant.depth = 10;
+        config.invariant.assert_all = false;
     });
 
     prj.add_test(