From b84c2bd7ef702adf7213ca6c51a0d6bf0307a1d4 Mon Sep 17 00:00:00 2001
From: Nikolay Strikhar <nikolay@learndash.com>
Date: Mon, 3 Aug 2026 15:41:03 +0200
Subject: [PATCH 1/3] Add the Notices queue and its interface

---
 README.md                           |   1 +
 src/Contracts/Notices_Interface.php |  60 +++++++
 src/Loader.php                      |  12 ++
 src/Notices.php                     | 169 ++++++++++++++++++++
 tests/unit/NoticesTest.php          | 236 ++++++++++++++++++++++++++++
 5 files changed, 478 insertions(+)
 create mode 100644 src/Contracts/Notices_Interface.php
 create mode 100644 src/Notices.php
 create mode 100644 tests/unit/NoticesTest.php

diff --git a/README.md b/README.md
index a463080..a16916f 100644
--- a/README.md
+++ b/README.md
@@ -94,6 +94,7 @@ Config::set_container( $container );
 | Interface | Default | Responsibility |
 |---|---|---|
 | `Contracts\Registrar_Interface` | `Registrar` | Holds the registered sub-plugins. |
+| `Contracts\Notices_Interface` | `Notices` | Notice queue and rendering. |
 
 **Set the container before your first `Loader::register()` call.** Resolution is memoized, so a
 container set afterwards is not consulted. `Loader::reset()` does discard the memo — but it also
diff --git a/src/Contracts/Notices_Interface.php b/src/Contracts/Notices_Interface.php
new file mode 100644
index 0000000..0843884
--- /dev/null
+++ b/src/Contracts/Notices_Interface.php
@@ -0,0 +1,60 @@
+<?php
+/**
+ * @package Nexcess\PluginAbsorber
+ */
+
+namespace Nexcess\PluginAbsorber\Contracts;
+
+use Nexcess\PluginAbsorber\Sub_Plugin;
+
+/**
+ * Admin notices raised by the absorber. Bind a replacement to render them your own way.
+ *
+ * @since 1.0.0
+ */
+interface Notices_Interface {
+	/**
+	 * Queue the "we deactivated the standalone for you" notice.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
+	 *
+	 * @return void
+	 */
+	public function queue_merge_notice( Sub_Plugin $sub_plugin ): void;
+
+	/**
+	 * Queue the "please deactivate the standalone yourself" notice.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
+	 *
+	 * @return void
+	 */
+	public function queue_conflict_notice( Sub_Plugin $sub_plugin ): void;
+
+	/**
+	 * Queue the "requirements not met" notice.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
+	 *
+	 * @return void
+	 */
+	public function queue_dependency_notice( Sub_Plugin $sub_plugin ): void;
+
+	/**
+	 * Render every queued notice, then clear the queue.
+	 *
+	 * An implementation must survive the request that queued it: the resolver redirects, so the
+	 * notice is almost never rendered by the request that raised it.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @return void
+	 */
+	public function render(): void;
+}
diff --git a/src/Loader.php b/src/Loader.php
index 97e69d9..8b67927 100644
--- a/src/Loader.php
+++ b/src/Loader.php
@@ -5,6 +5,7 @@
 
 namespace Nexcess\PluginAbsorber;
 
+use Nexcess\PluginAbsorber\Contracts\Notices_Interface;
 use Nexcess\PluginAbsorber\Contracts\Registrar_Interface;
 use Nexcess\PluginAbsorber\Exceptions\Config_Exception;
 
@@ -92,6 +93,17 @@ public static function registrar(): Registrar_Interface {
 		return self::resolve( Registrar_Interface::class, Registrar::class );
 	}
 
+	/**
+	 * @since 1.0.0
+	 *
+	 * @throws Config_Exception When the container binding does not implement the interface.
+	 *
+	 * @return Notices_Interface
+	 */
+	public static function notices(): Notices_Interface {
+		return self::resolve( Notices_Interface::class, Notices::class );
+	}
+
 	/**
 	 * Register one bundled sub-plugin. Call once per sub-plugin, before boot().
 	 *
diff --git a/src/Notices.php b/src/Notices.php
new file mode 100644
index 0000000..63a3af7
--- /dev/null
+++ b/src/Notices.php
@@ -0,0 +1,169 @@
+<?php
+/**
+ * @package Nexcess\PluginAbsorber
+ */
+
+namespace Nexcess\PluginAbsorber;
+
+use Nexcess\PluginAbsorber\Contracts\Notices_Interface;
+
+/**
+ * Default notices: a transient-backed queue that survives the resolver's redirect.
+ *
+ * Deliberately minimal markup so the library stays dependency-free. A host already using
+ * stellarwp/admin-notices can bind its own implementation and render from the same store.
+ *
+ * @since 1.0.0
+ */
+class Notices implements Notices_Interface {
+	/**
+	 * @since 1.0.0
+	 *
+	 * @var string
+	 */
+	private const TYPE_MERGE = 'merge';
+
+	/**
+	 * @since 1.0.0
+	 *
+	 * @var string
+	 */
+	private const TYPE_CONFLICT = 'conflict';
+
+	/**
+	 * @since 1.0.0
+	 *
+	 * @var string
+	 */
+	private const TYPE_DEPENDENCY = 'dependency';
+
+	/**
+	 * @since 1.0.0
+	 *
+	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
+	 *
+	 * @return void
+	 */
+	public function queue_merge_notice( Sub_Plugin $sub_plugin ): void {
+		$this->queue(
+			$sub_plugin,
+			self::TYPE_MERGE,
+			$sub_plugin->get_conflict_notice_message(
+				sprintf(
+					'%s has been deactivated because it is now bundled and loaded automatically.',
+					$sub_plugin->get_slug()
+				)
+			)
+		);
+	}
+
+	/**
+	 * The default differs from the merge notice's on purpose: this one asks the user to act,
+	 * where that one reports something already done.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
+	 *
+	 * @return void
+	 */
+	public function queue_conflict_notice( Sub_Plugin $sub_plugin ): void {
+		$this->queue(
+			$sub_plugin,
+			self::TYPE_CONFLICT,
+			$sub_plugin->get_conflict_notice_message(
+				sprintf(
+					'%s is now bundled and loaded automatically. You can safely deactivate the standalone plugin.',
+					$sub_plugin->get_slug()
+				)
+			)
+		);
+	}
+
+	/**
+	 * @since 1.0.0
+	 *
+	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
+	 *
+	 * @return void
+	 */
+	public function queue_dependency_notice( Sub_Plugin $sub_plugin ): void {
+		$this->queue( $sub_plugin, self::TYPE_DEPENDENCY, $sub_plugin->get_dependency_notice_message() );
+	}
+
+	/**
+	 * @since 1.0.0
+	 *
+	 * @return void
+	 */
+	public function render(): void {
+		$queue = $this->get_queue();
+
+		if ( $queue === [] ) {
+			return;
+		}
+
+		delete_transient( $this->transient_name() );
+
+		foreach ( $queue as $message ) {
+			if ( $message === '' ) {
+				continue;
+			}
+
+			printf(
+				'<div class="notice notice-warning is-dismissible"><p>%s</p></div>',
+				esc_html( $message )
+			);
+		}
+	}
+
+	/**
+	 * Store one notice, keyed by slug and type so different types can coexist.
+	 *
+	 * A sub-plugin can legitimately earn a merge notice while the conflict is resolved and a
+	 * dependency notice while the load is attempted, in the same request. Keying by slug alone
+	 * would silently drop one of them.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
+	 * @param string     $type       Notice type.
+	 * @param string     $message    Resolved message.
+	 *
+	 * @return void
+	 */
+	private function queue( Sub_Plugin $sub_plugin, string $type, string $message ): void {
+		$queue = $this->get_queue();
+
+		$queue[ $sub_plugin->get_slug() . ':' . $type ] = $message;
+
+		// No expiry: the queue has to outlive the redirect and wait for the next admin load.
+		set_transient( $this->transient_name(), $queue, 0 );
+	}
+
+	/**
+	 * @since 1.0.0
+	 *
+	 * @return array<string,string>
+	 */
+	private function get_queue(): array {
+		$queue = get_transient( $this->transient_name() );
+
+		if ( ! is_array( $queue ) ) {
+			return [];
+		}
+
+		// The store is shared with whatever else can write an option, and the render path prints
+		// what it finds. Anything that is not a string message is dropped rather than coerced.
+		return array_filter( $queue, 'is_string' );
+	}
+
+	/**
+	 * @since 1.0.0
+	 *
+	 * @return string
+	 */
+	private function transient_name(): string {
+		return Config::get_hook_prefix() . '_plugin_absorber_notices';
+	}
+}
diff --git a/tests/unit/NoticesTest.php b/tests/unit/NoticesTest.php
new file mode 100644
index 0000000..74b900b
--- /dev/null
+++ b/tests/unit/NoticesTest.php
@@ -0,0 +1,236 @@
+<?php
+/**
+ * @package Nexcess\PluginAbsorber
+ */
+
+namespace Nexcess\PluginAbsorber\Tests\Unit;
+
+use Codeception\TestCase\WPTestCase;
+use Nexcess\PluginAbsorber\Config;
+use Nexcess\PluginAbsorber\Contracts\Notices_Interface;
+use Nexcess\PluginAbsorber\Loader;
+use Nexcess\PluginAbsorber\Notices;
+use Nexcess\PluginAbsorber\Sub_Plugin;
+
+/**
+ * @since 1.0.0
+ */
+class NoticesTest extends WPTestCase {
+	private const TRANSIENT = 'give_plugin_absorber_notices';
+
+	public function setUp(): void {
+		parent::setUp();
+
+		Loader::reset();
+		Config::reset();
+		Config::set_hook_prefix( 'give' );
+		delete_transient( self::TRANSIENT );
+	}
+
+	public function tearDown(): void {
+		delete_transient( self::TRANSIENT );
+		Loader::reset();
+		Config::reset();
+		parent::tearDown();
+	}
+
+	/**
+	 * @param array<string,mixed> $overrides Config overrides.
+	 */
+	private function make_sub_plugin( array $overrides = [] ): Sub_Plugin {
+		return new Sub_Plugin(
+			array_merge(
+				[
+					'slug'                   => 'give-recurring',
+					'bundled_plugin_file'    => '/tmp/give-recurring.php',
+					'plugin_loaded_constant' => 'GIVE_RECURRING_VERSION_NOTICES',
+				],
+				$overrides
+			)
+		);
+	}
+
+	private function render_to_string( Notices $notices ): string {
+		ob_start();
+		$notices->render();
+
+		return (string) ob_get_clean();
+	}
+
+	public function test_the_loader_resolves_the_default_notices(): void {
+		$this->assertInstanceOf( Notices::class, Loader::notices() );
+	}
+
+	public function test_the_default_notices_satisfy_the_contract(): void {
+		$this->assertInstanceOf( Notices_Interface::class, new Notices() );
+	}
+
+	public function test_it_queues_a_merge_notice_into_the_transient(): void {
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Bundled now.' ] ) );
+
+		$queue = get_transient( self::TRANSIENT );
+
+		$this->assertIsArray( $queue );
+		$this->assertArrayHasKey( 'give-recurring:merge', $queue );
+		$this->assertSame( 'Bundled now.', $queue['give-recurring:merge'] );
+	}
+
+	public function test_the_merge_notice_falls_back_to_a_default_message(): void {
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
+
+		$queue = get_transient( self::TRANSIENT );
+
+		$this->assertStringContainsString( 'give-recurring', $queue['give-recurring:merge'] );
+		$this->assertNotSame( '', $queue['give-recurring:merge'] );
+	}
+
+	public function test_it_queues_a_conflict_notice(): void {
+		( new Notices() )->queue_conflict_notice( $this->make_sub_plugin() );
+
+		$this->assertArrayHasKey( 'give-recurring:conflict', get_transient( self::TRANSIENT ) );
+	}
+
+	/**
+	 * The two conflict-flavoured notices say opposite things — one reports a deactivation that
+	 * already happened, the other asks the user to do it. Sharing a default would be wrong.
+	 */
+	public function test_the_merge_and_conflict_defaults_differ(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin() );
+		$notices->queue_conflict_notice( $this->make_sub_plugin() );
+
+		$queue = get_transient( self::TRANSIENT );
+
+		$this->assertNotSame( $queue['give-recurring:merge'], $queue['give-recurring:conflict'] );
+	}
+
+	public function test_a_configured_message_is_used_for_both_conflict_types(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Ours.' ] ) );
+		$notices->queue_conflict_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Ours.' ] ) );
+
+		$queue = get_transient( self::TRANSIENT );
+
+		$this->assertSame( 'Ours.', $queue['give-recurring:merge'] );
+		$this->assertSame( 'Ours.', $queue['give-recurring:conflict'] );
+	}
+
+	public function test_it_queues_a_dependency_notice_using_the_sub_plugin_message(): void {
+		( new Notices() )->queue_dependency_notice( $this->make_sub_plugin( [ 'dependency_notice_message' => 'Needs Give.' ] ) );
+
+		$this->assertSame( 'Needs Give.', get_transient( self::TRANSIENT )['give-recurring:dependency'] );
+	}
+
+	public function test_the_dependency_notice_falls_back_to_the_sub_plugin_default(): void {
+		( new Notices() )->queue_dependency_notice( $this->make_sub_plugin() );
+
+		$this->assertSame(
+			'give-recurring could not be loaded because its requirements are not met.',
+			get_transient( self::TRANSIENT )['give-recurring:dependency']
+		);
+	}
+
+	public function test_queueing_the_same_slug_and_type_twice_does_not_duplicate(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin() );
+		$notices->queue_merge_notice( $this->make_sub_plugin() );
+
+		$this->assertCount( 1, get_transient( self::TRANSIENT ) );
+	}
+
+	public function test_one_slug_can_hold_notices_of_different_types(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin() );
+		$notices->queue_dependency_notice( $this->make_sub_plugin() );
+
+		$this->assertCount( 2, get_transient( self::TRANSIENT ) );
+	}
+
+	public function test_different_slugs_do_not_collide(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin() );
+		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'slug' => 'give-fee-recovery' ] ) );
+
+		$queue = get_transient( self::TRANSIENT );
+
+		$this->assertCount( 2, $queue );
+		$this->assertArrayHasKey( 'give-recurring:merge', $queue );
+		$this->assertArrayHasKey( 'give-fee-recovery:merge', $queue );
+	}
+
+	public function test_render_outputs_dismissible_warning_markup(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Bundled now.' ] ) );
+
+		$output = $this->render_to_string( $notices );
+
+		$this->assertStringContainsString( 'notice notice-warning is-dismissible', $output );
+		$this->assertStringContainsString( 'Bundled now.', $output );
+	}
+
+	public function test_render_escapes_the_message(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => '<script>alert(1)</script>' ] ) );
+
+		$output = $this->render_to_string( $notices );
+
+		$this->assertStringNotContainsString( '<script>', $output );
+		$this->assertStringContainsString( '&lt;script&gt;', $output );
+	}
+
+	public function test_render_clears_the_queue(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin() );
+
+		$this->render_to_string( $notices );
+
+		$this->assertFalse( get_transient( self::TRANSIENT ) );
+		$this->assertSame( '', $this->render_to_string( $notices ), 'A second render must output nothing.' );
+	}
+
+	public function test_render_outputs_every_queued_notice(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'First.' ] ) );
+		$notices->queue_dependency_notice( $this->make_sub_plugin( [ 'dependency_notice_message' => 'Second.' ] ) );
+
+		$output = $this->render_to_string( $notices );
+
+		$this->assertStringContainsString( 'First.', $output );
+		$this->assertStringContainsString( 'Second.', $output );
+	}
+
+	public function test_render_outputs_nothing_when_the_queue_is_empty(): void {
+		$this->assertSame( '', $this->render_to_string( new Notices() ) );
+	}
+
+	public function test_the_queue_survives_a_simulated_redirect(): void {
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Bundled now.' ] ) );
+
+		// A redirect ends the request; the next one builds a fresh object against the same store.
+		$output = $this->render_to_string( new Notices() );
+
+		$this->assertStringContainsString( 'Bundled now.', $output );
+	}
+
+	/**
+	 * The queue outlives the request that filled it, so it must not expire before the admin load
+	 * that renders it. WordPress stores a no-expiry transient without a timeout option.
+	 */
+	public function test_the_queue_is_stored_without_an_expiry(): void {
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
+
+		$this->assertFalse( get_option( '_transient_timeout_' . self::TRANSIENT ) );
+	}
+
+	public function test_the_transient_is_keyed_by_the_hook_prefix(): void {
+		Config::reset();
+		Config::set_hook_prefix( 'woo' );
+
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
+
+		$this->assertIsArray( get_transient( 'woo_plugin_absorber_notices' ) );
+		$this->assertFalse( get_transient( self::TRANSIENT ) );
+
+		delete_transient( 'woo_plugin_absorber_notices' );
+	}
+}

From 1ead4a31c99ac588483106e0a444dd9c799a9781 Mon Sep 17 00:00:00 2001
From: Nikolay Strikhar <nikolay@learndash.com>
Date: Mon, 3 Aug 2026 15:54:54 +0200
Subject: [PATCH 2/3] Address review: make the notice queue durable and gate
 who consumes it

Three defects, each of which loses the one warning a site owner gets that
their plugin was deactivated.

Storage was a transient. Verified in core: set_transient() short-circuits
to wp_cache_set() and never touches the database when an external object
cache is present, so on a Redis or Memcached site the queue lived only in
the cache -- where wp_cache_flush(), which deploy scripts and every purge
button call, destroys it. The merge notice is raised once and never
re-queued. It is an option now.

The queue was per-site while the deactivation is network-wide. The resolver
passes $network_wide to deactivate_plugins(), removing the plugin from every
site, but the explanation landed in whichever site's options table served
the request. On a fifty-site network the superadmin would never find it.
Multisite uses network options now.

render() consumes the queue and had no capability check, and it is wired to
a hook that fires for anyone who can reach wp-admin. A subscriber loading
profile.php silently swallowed the notice, and nothing re-queues it. It
checks activate_plugins first, which on multisite correctly resolves to
superadmins.

Also drop non-string entries instead of printing them, expose
option_name() so a host can render the same queue without replacing the
implementation, and cover the corrupted-queue, capability, cache-flush and
missing-prefix paths.
---
 README.md                           |   4 +
 src/Contracts/Notices_Interface.php |  20 +++-
 src/Notices.php                     |  90 +++++++++++++--
 tests/unit/NoticesTest.php          | 173 +++++++++++++++++++++++-----
 4 files changed, 245 insertions(+), 42 deletions(-)

diff --git a/README.md b/README.md
index a16916f..fe5bd41 100644
--- a/README.md
+++ b/README.md
@@ -96,6 +96,10 @@ Config::set_container( $container );
 | `Contracts\Registrar_Interface` | `Registrar` | Holds the registered sub-plugins. |
 | `Contracts\Notices_Interface` | `Notices` | Notice queue and rendering. |
 
+The default notices queue into the option `{prefix}_plugin_absorber_notices` — a network option on
+multisite — and render for users who can `activate_plugins`. Read `Notices::option_name()` if you
+want to render them yourself without replacing the queue.
+
 **Set the container before your first `Loader::register()` call.** Resolution is memoized, so a
 container set afterwards is not consulted. `Loader::reset()` does discard the memo — but it also
 discards every registration, so reaching for it after registering leaves nothing to load.
diff --git a/src/Contracts/Notices_Interface.php b/src/Contracts/Notices_Interface.php
index 0843884..a75c04e 100644
--- a/src/Contracts/Notices_Interface.php
+++ b/src/Contracts/Notices_Interface.php
@@ -5,6 +5,7 @@
 
 namespace Nexcess\PluginAbsorber\Contracts;
 
+use Nexcess\PluginAbsorber\Exceptions\Config_Exception;
 use Nexcess\PluginAbsorber\Sub_Plugin;
 
 /**
@@ -16,10 +17,16 @@ interface Notices_Interface {
 	/**
 	 * Queue the "we deactivated the standalone for you" notice.
 	 *
+	 * Queued after the deactivation has already happened, and raised exactly once — nothing
+	 * re-queues it on a later request, so an implementation that drops it drops the only warning
+	 * the site owner gets.
+	 *
 	 * @since 1.0.0
 	 *
 	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function queue_merge_notice( Sub_Plugin $sub_plugin ): void;
@@ -31,6 +38,8 @@ public function queue_merge_notice( Sub_Plugin $sub_plugin ): void;
 	 *
 	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function queue_conflict_notice( Sub_Plugin $sub_plugin ): void;
@@ -42,6 +51,8 @@ public function queue_conflict_notice( Sub_Plugin $sub_plugin ): void;
 	 *
 	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function queue_dependency_notice( Sub_Plugin $sub_plugin ): void;
@@ -49,11 +60,16 @@ public function queue_dependency_notice( Sub_Plugin $sub_plugin ): void;
 	/**
 	 * Render every queued notice, then clear the queue.
 	 *
-	 * An implementation must survive the request that queued it: the resolver redirects, so the
-	 * notice is almost never rendered by the request that raised it.
+	 * Two obligations an implementation must honour. It has to survive the request that queued
+	 * it, because the resolver redirects and the notice is almost never rendered by the request
+	 * that raised it. And because rendering consumes the queue, it must not render for a user who
+	 * cannot act on the notice — otherwise any logged-in user loading an admin page swallows a
+	 * warning meant for an administrator.
 	 *
 	 * @since 1.0.0
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function render(): void;
diff --git a/src/Notices.php b/src/Notices.php
index 63a3af7..2a71429 100644
--- a/src/Notices.php
+++ b/src/Notices.php
@@ -6,12 +6,20 @@
 namespace Nexcess\PluginAbsorber;
 
 use Nexcess\PluginAbsorber\Contracts\Notices_Interface;
+use Nexcess\PluginAbsorber\Exceptions\Config_Exception;
 
 /**
- * Default notices: a transient-backed queue that survives the resolver's redirect.
+ * Default notices: an option-backed queue that survives the resolver's redirect.
+ *
+ * An option rather than a transient. With an external object cache, `set_transient()` never
+ * touches the database at all — the queue would live only in Redis or Memcached, where a routine
+ * `wp_cache_flush()` from a deploy script or a "purge cache" button destroys it. The merge notice
+ * is raised once and never again, so losing it means a site owner is never told their plugin was
+ * deactivated. This queue is not a cache.
  *
  * Deliberately minimal markup so the library stays dependency-free. A host already using
- * stellarwp/admin-notices can bind its own implementation and render from the same store.
+ * stellarwp/admin-notices can bind its own implementation and read the same option, whose name is
+ * `self::option_name()`.
  *
  * @since 1.0.0
  */
@@ -37,11 +45,26 @@ class Notices implements Notices_Interface {
 	 */
 	private const TYPE_DEPENDENCY = 'dependency';
 
+	/**
+	 * Capability required to see, and thereby consume, the queue.
+	 *
+	 * Rendering clears the queue, so a user who cannot act on a notice must not be shown one:
+	 * a subscriber loading their profile page would otherwise silently swallow the only warning
+	 * an administrator was ever going to get.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @var string
+	 */
+	private const CAPABILITY = 'activate_plugins';
+
 	/**
 	 * @since 1.0.0
 	 *
 	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function queue_merge_notice( Sub_Plugin $sub_plugin ): void {
@@ -65,6 +88,8 @@ public function queue_merge_notice( Sub_Plugin $sub_plugin ): void {
 	 *
 	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function queue_conflict_notice( Sub_Plugin $sub_plugin ): void {
@@ -85,6 +110,8 @@ public function queue_conflict_notice( Sub_Plugin $sub_plugin ): void {
 	 *
 	 * @param Sub_Plugin $sub_plugin Sub-plugin concerned.
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function queue_dependency_notice( Sub_Plugin $sub_plugin ): void {
@@ -94,17 +121,21 @@ public function queue_dependency_notice( Sub_Plugin $sub_plugin ): void {
 	/**
 	 * @since 1.0.0
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	public function render(): void {
+		if ( ! current_user_can( self::CAPABILITY ) ) {
+			return;
+		}
+
 		$queue = $this->get_queue();
 
 		if ( $queue === [] ) {
 			return;
 		}
 
-		delete_transient( $this->transient_name() );
-
 		foreach ( $queue as $message ) {
 			if ( $message === '' ) {
 				continue;
@@ -115,6 +146,21 @@ public function render(): void {
 				esc_html( $message )
 			);
 		}
+
+		$this->clear_queue();
+	}
+
+	/**
+	 * The option name backing the queue. Read it directly to render these notices yourself.
+	 *
+	 * @since 1.0.0
+	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
+	 * @return string
+	 */
+	public static function option_name(): string {
+		return Config::get_hook_prefix() . '_plugin_absorber_notices';
 	}
 
 	/**
@@ -130,6 +176,8 @@ public function render(): void {
 	 * @param string     $type       Notice type.
 	 * @param string     $message    Resolved message.
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return void
 	 */
 	private function queue( Sub_Plugin $sub_plugin, string $type, string $message ): void {
@@ -137,33 +185,51 @@ private function queue( Sub_Plugin $sub_plugin, string $type, string $message ):
 
 		$queue[ $sub_plugin->get_slug() . ':' . $type ] = $message;
 
-		// No expiry: the queue has to outlive the redirect and wait for the next admin load.
-		set_transient( $this->transient_name(), $queue, 0 );
+		if ( is_multisite() ) {
+			update_site_option( self::option_name(), $queue );
+
+			return;
+		}
+
+		// Not autoloaded: the queue is empty on almost every request, and only the admin reads it.
+		update_option( self::option_name(), $queue, false );
 	}
 
 	/**
 	 * @since 1.0.0
 	 *
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
 	 * @return array<string,string>
 	 */
 	private function get_queue(): array {
-		$queue = get_transient( $this->transient_name() );
+		$queue = is_multisite()
+			? get_site_option( self::option_name(), [] )
+			: get_option( self::option_name(), [] );
 
 		if ( ! is_array( $queue ) ) {
 			return [];
 		}
 
-		// The store is shared with whatever else can write an option, and the render path prints
-		// what it finds. Anything that is not a string message is dropped rather than coerced.
+		// Anything that is not a string message is dropped rather than printed. queue() writes
+		// the filtered array back, so a corrupted entry heals itself.
 		return array_filter( $queue, 'is_string' );
 	}
 
 	/**
 	 * @since 1.0.0
 	 *
-	 * @return string
+	 * @throws Config_Exception When no hook prefix has been set.
+	 *
+	 * @return void
 	 */
-	private function transient_name(): string {
-		return Config::get_hook_prefix() . '_plugin_absorber_notices';
+	private function clear_queue(): void {
+		if ( is_multisite() ) {
+			delete_site_option( self::option_name() );
+
+			return;
+		}
+
+		delete_option( self::option_name() );
 	}
 }
diff --git a/tests/unit/NoticesTest.php b/tests/unit/NoticesTest.php
index 74b900b..2a9d7d5 100644
--- a/tests/unit/NoticesTest.php
+++ b/tests/unit/NoticesTest.php
@@ -8,15 +8,17 @@
 use Codeception\TestCase\WPTestCase;
 use Nexcess\PluginAbsorber\Config;
 use Nexcess\PluginAbsorber\Contracts\Notices_Interface;
+use Nexcess\PluginAbsorber\Exceptions\Config_Exception;
 use Nexcess\PluginAbsorber\Loader;
 use Nexcess\PluginAbsorber\Notices;
 use Nexcess\PluginAbsorber\Sub_Plugin;
+use WP_User;
 
 /**
  * @since 1.0.0
  */
 class NoticesTest extends WPTestCase {
-	private const TRANSIENT = 'give_plugin_absorber_notices';
+	private const OPTION = 'give_plugin_absorber_notices';
 
 	public function setUp(): void {
 		parent::setUp();
@@ -24,16 +26,57 @@ public function setUp(): void {
 		Loader::reset();
 		Config::reset();
 		Config::set_hook_prefix( 'give' );
-		delete_transient( self::TRANSIENT );
+		$this->clear_queue();
+
+		// render() consumes the queue, so it is gated on a capability. Most tests care about the
+		// queue rather than the gate, so they run as someone who has it.
+		$user_id = $this->factory()->user->create( [ 'role' => 'administrator' ] );
+
+		// On multisite, activate_plugins maps through manage_network_plugins unless the network
+		// has opened the plugins menu to site admins, so a plain administrator is not enough.
+		if ( is_multisite() ) {
+			( new WP_User( $user_id ) )->add_cap( 'manage_network_plugins' );
+		}
+
+		wp_set_current_user( $user_id );
 	}
 
 	public function tearDown(): void {
-		delete_transient( self::TRANSIENT );
+		$this->clear_queue();
+		delete_option( 'woo_plugin_absorber_notices' );
+		delete_site_option( 'woo_plugin_absorber_notices' );
 		Loader::reset();
 		Config::reset();
 		parent::tearDown();
 	}
 
+	private function clear_queue(): void {
+		delete_option( self::OPTION );
+		delete_site_option( self::OPTION );
+	}
+
+	/**
+	 * @return array<string,string>|false
+	 */
+	private function queue() {
+		return is_multisite()
+			? get_site_option( self::OPTION, false )
+			: get_option( self::OPTION, false );
+	}
+
+	/**
+	 * @param array<string,mixed> $queue Raw queue contents.
+	 */
+	private function seed_queue( array $queue ): void {
+		if ( is_multisite() ) {
+			update_site_option( self::OPTION, $queue );
+
+			return;
+		}
+
+		update_option( self::OPTION, $queue, false );
+	}
+
 	/**
 	 * @param array<string,mixed> $overrides Config overrides.
 	 */
@@ -65,10 +108,10 @@ public function test_the_default_notices_satisfy_the_contract(): void {
 		$this->assertInstanceOf( Notices_Interface::class, new Notices() );
 	}
 
-	public function test_it_queues_a_merge_notice_into_the_transient(): void {
+	public function test_it_queues_a_merge_notice(): void {
 		( new Notices() )->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Bundled now.' ] ) );
 
-		$queue = get_transient( self::TRANSIENT );
+		$queue = $this->queue();
 
 		$this->assertIsArray( $queue );
 		$this->assertArrayHasKey( 'give-recurring:merge', $queue );
@@ -78,7 +121,7 @@ public function test_it_queues_a_merge_notice_into_the_transient(): void {
 	public function test_the_merge_notice_falls_back_to_a_default_message(): void {
 		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
 
-		$queue = get_transient( self::TRANSIENT );
+		$queue = $this->queue();
 
 		$this->assertStringContainsString( 'give-recurring', $queue['give-recurring:merge'] );
 		$this->assertNotSame( '', $queue['give-recurring:merge'] );
@@ -87,7 +130,7 @@ public function test_the_merge_notice_falls_back_to_a_default_message(): void {
 	public function test_it_queues_a_conflict_notice(): void {
 		( new Notices() )->queue_conflict_notice( $this->make_sub_plugin() );
 
-		$this->assertArrayHasKey( 'give-recurring:conflict', get_transient( self::TRANSIENT ) );
+		$this->assertArrayHasKey( 'give-recurring:conflict', $this->queue() );
 	}
 
 	/**
@@ -99,7 +142,7 @@ public function test_the_merge_and_conflict_defaults_differ(): void {
 		$notices->queue_merge_notice( $this->make_sub_plugin() );
 		$notices->queue_conflict_notice( $this->make_sub_plugin() );
 
-		$queue = get_transient( self::TRANSIENT );
+		$queue = $this->queue();
 
 		$this->assertNotSame( $queue['give-recurring:merge'], $queue['give-recurring:conflict'] );
 	}
@@ -109,7 +152,7 @@ public function test_a_configured_message_is_used_for_both_conflict_types(): voi
 		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Ours.' ] ) );
 		$notices->queue_conflict_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Ours.' ] ) );
 
-		$queue = get_transient( self::TRANSIENT );
+		$queue = $this->queue();
 
 		$this->assertSame( 'Ours.', $queue['give-recurring:merge'] );
 		$this->assertSame( 'Ours.', $queue['give-recurring:conflict'] );
@@ -118,7 +161,7 @@ public function test_a_configured_message_is_used_for_both_conflict_types(): voi
 	public function test_it_queues_a_dependency_notice_using_the_sub_plugin_message(): void {
 		( new Notices() )->queue_dependency_notice( $this->make_sub_plugin( [ 'dependency_notice_message' => 'Needs Give.' ] ) );
 
-		$this->assertSame( 'Needs Give.', get_transient( self::TRANSIENT )['give-recurring:dependency'] );
+		$this->assertSame( 'Needs Give.', $this->queue()['give-recurring:dependency'] );
 	}
 
 	public function test_the_dependency_notice_falls_back_to_the_sub_plugin_default(): void {
@@ -126,7 +169,7 @@ public function test_the_dependency_notice_falls_back_to_the_sub_plugin_default(
 
 		$this->assertSame(
 			'give-recurring could not be loaded because its requirements are not met.',
-			get_transient( self::TRANSIENT )['give-recurring:dependency']
+			$this->queue()['give-recurring:dependency']
 		);
 	}
 
@@ -135,7 +178,7 @@ public function test_queueing_the_same_slug_and_type_twice_does_not_duplicate():
 		$notices->queue_merge_notice( $this->make_sub_plugin() );
 		$notices->queue_merge_notice( $this->make_sub_plugin() );
 
-		$this->assertCount( 1, get_transient( self::TRANSIENT ) );
+		$this->assertCount( 1, $this->queue() );
 	}
 
 	public function test_one_slug_can_hold_notices_of_different_types(): void {
@@ -143,7 +186,7 @@ public function test_one_slug_can_hold_notices_of_different_types(): void {
 		$notices->queue_merge_notice( $this->make_sub_plugin() );
 		$notices->queue_dependency_notice( $this->make_sub_plugin() );
 
-		$this->assertCount( 2, get_transient( self::TRANSIENT ) );
+		$this->assertCount( 2, $this->queue() );
 	}
 
 	public function test_different_slugs_do_not_collide(): void {
@@ -151,7 +194,7 @@ public function test_different_slugs_do_not_collide(): void {
 		$notices->queue_merge_notice( $this->make_sub_plugin() );
 		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'slug' => 'give-fee-recovery' ] ) );
 
-		$queue = get_transient( self::TRANSIENT );
+		$queue = $this->queue();
 
 		$this->assertCount( 2, $queue );
 		$this->assertArrayHasKey( 'give-recurring:merge', $queue );
@@ -184,7 +227,7 @@ public function test_render_clears_the_queue(): void {
 
 		$this->render_to_string( $notices );
 
-		$this->assertFalse( get_transient( self::TRANSIENT ) );
+		$this->assertFalse( $this->queue() );
 		$this->assertSame( '', $this->render_to_string( $notices ), 'A second render must output nothing.' );
 	}
 
@@ -203,34 +246,108 @@ public function test_render_outputs_nothing_when_the_queue_is_empty(): void {
 		$this->assertSame( '', $this->render_to_string( new Notices() ) );
 	}
 
-	public function test_the_queue_survives_a_simulated_redirect(): void {
-		( new Notices() )->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Bundled now.' ] ) );
+	/**
+	 * Rendering consumes the queue, so a user who cannot act on the notice must neither see it
+	 * nor destroy it. The merge notice is raised once and never re-queued.
+	 */
+	public function test_render_does_nothing_for_a_user_who_cannot_activate_plugins(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Bundled now.' ] ) );
 
-		// A redirect ends the request; the next one builds a fresh object against the same store.
-		$output = $this->render_to_string( new Notices() );
+		wp_set_current_user( $this->factory()->user->create( [ 'role' => 'subscriber' ] ) );
 
-		$this->assertStringContainsString( 'Bundled now.', $output );
+		$this->assertSame( '', $this->render_to_string( $notices ) );
+		$this->assertIsArray( $this->queue(), 'The queue must survive for someone who can act on it.' );
+	}
+
+	public function test_render_does_nothing_for_a_logged_out_visitor(): void {
+		$notices = new Notices();
+		$notices->queue_merge_notice( $this->make_sub_plugin() );
+
+		wp_set_current_user( 0 );
+
+		$this->assertSame( '', $this->render_to_string( $notices ) );
+		$this->assertIsArray( $this->queue() );
 	}
 
 	/**
-	 * The queue outlives the request that filled it, so it must not expire before the admin load
-	 * that renders it. WordPress stores a no-expiry transient without a timeout option.
+	 * The redirect ends the request, so the queue has to come back off durable storage rather
+	 * than out of the object cache the redirecting request happened to warm.
 	 */
-	public function test_the_queue_is_stored_without_an_expiry(): void {
+	public function test_the_queue_survives_a_cache_flush(): void {
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin( [ 'conflict_notice_message' => 'Bundled now.' ] ) );
+
+		wp_cache_flush();
+
+		$this->assertStringContainsString( 'Bundled now.', $this->render_to_string( new Notices() ) );
+	}
+
+	public function test_it_drops_entries_that_are_not_messages(): void {
+		$this->seed_queue(
+			[
+				'a:merge' => 'Fine.',
+				'b:merge' => [ 'nested' ],
+				'c:merge' => null,
+				'd:merge' => 42,
+			]
+		);
+
+		$output = $this->render_to_string( new Notices() );
+
+		$this->assertStringContainsString( 'Fine.', $output );
+		$this->assertStringNotContainsString( 'Array', $output );
+		$this->assertStringNotContainsString( '42', $output );
+	}
+
+	public function test_it_renders_nothing_for_an_empty_message(): void {
+		$this->seed_queue( [ 'a:merge' => '' ] );
+
+		$this->assertSame( '', $this->render_to_string( new Notices() ) );
+	}
+
+	public function test_a_corrupted_queue_heals_on_the_next_write(): void {
+		$this->seed_queue( [ 'a:merge' => [ 'nested' ] ] );
+
 		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
 
-		$this->assertFalse( get_option( '_transient_timeout_' . self::TRANSIENT ) );
+		$this->assertSame( [ 'give-recurring:merge' ], array_keys( $this->queue() ) );
 	}
 
-	public function test_the_transient_is_keyed_by_the_hook_prefix(): void {
+	public function test_the_option_is_keyed_by_the_hook_prefix(): void {
 		Config::reset();
 		Config::set_hook_prefix( 'woo' );
 
+		$this->assertSame( 'woo_plugin_absorber_notices', Notices::option_name() );
+
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
+
+		$this->assertIsArray(
+			is_multisite()
+				? get_site_option( 'woo_plugin_absorber_notices', false )
+				: get_option( 'woo_plugin_absorber_notices', false )
+		);
+		$this->assertFalse( $this->queue() );
+	}
+
+	public function test_queueing_needs_a_hook_prefix(): void {
+		Config::reset();
+
+		$this->expectException( Config_Exception::class );
+
 		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
+	}
 
-		$this->assertIsArray( get_transient( 'woo_plugin_absorber_notices' ) );
-		$this->assertFalse( get_transient( self::TRANSIENT ) );
+	/**
+	 * The queue is empty on nearly every request and only ever read in the admin, so it must not
+	 * ride along in the autoloaded bundle on every front-end request.
+	 */
+	public function test_the_queue_is_not_autoloaded(): void {
+		if ( is_multisite() ) {
+			$this->markTestSkipped( 'Network options are not part of the per-site autoload bundle.' );
+		}
+
+		( new Notices() )->queue_merge_notice( $this->make_sub_plugin() );
 
-		delete_transient( 'woo_plugin_absorber_notices' );
+		$this->assertNotContains( self::OPTION, array_keys( wp_load_alloptions() ) );
 	}
 }

From a8e8860db5ac9ffccdb8869af8b5fbd122fe6b09 Mon Sep 17 00:00:00 2001
From: Nikolay Strikhar <nikolay@learndash.com>
Date: Mon, 3 Aug 2026 15:54:54 +0200
Subject: [PATCH 3/3] Plan: store notices in an option and render them on
 all_admin_notices

---
 .../plans/2026-07-31-plugin-absorber.md       | 49 +++++++++++++++----
 1 file changed, 39 insertions(+), 10 deletions(-)

diff --git a/docs/superpowers/plans/2026-07-31-plugin-absorber.md b/docs/superpowers/plans/2026-07-31-plugin-absorber.md
index 3904005..9a14bd5 100644
--- a/docs/superpowers/plans/2026-07-31-plugin-absorber.md
+++ b/docs/superpowers/plans/2026-07-31-plugin-absorber.md
@@ -17,7 +17,7 @@ Every task's requirements implicitly include this section.
 - **PHP floor:** `>=7.4`. **WordPress floor:** 6.4 (the `wp_admin_notice_markup` filter). Stated in the README only — WordPress is not a Composer dependency, so it is not enforceable in `require`.
 - **Class naming:** `Snake_Case` (`Sub_Plugin`, `Conflict_Policy`, `Config_Exception`). Methods fully spelled out and readable. Config keys descriptive and WordPress-centric.
 - **Filter names:** `"{$hook_prefix}/plugin_absorber/should_load"` and `"{$hook_prefix}/plugin_absorber/conflict_policy"`.
-- **Storage keys:** option `"{$hook_prefix}_plugin_absorber_activations"`, transient `"{$hook_prefix}_plugin_absorber_notices"`.
+- **Storage keys:** option `"{$hook_prefix}_plugin_absorber_activations"`, option `"{$hook_prefix}_plugin_absorber_notices"`. **Amended 2026-08-03 (PR 10 review):** the notice queue was specified as a *transient* and is now an option. `set_transient()` returns before touching the database whenever an external object cache is present, so on any Redis or Memcached site the queue would live only in the cache — where a routine `wp_cache_flush()` from a deploy script or a "purge cache" button destroys it. The merge notice is raised exactly once and never re-queued, so losing it means a site owner is never told their plugin was deactivated. On multisite both this and the activation option are network options, because the resolver deactivates network-wide.
 - **Production dependencies:** `stellarwp/container-contract` only. `lucatume/di52` is dev-only. No other StellarWP library.
 - **PR size cap:** ≤10 files per PR, tests and test infrastructure excluded. No logic-bearing PR exceeds 4 source files.
 - **PR body format** — exactly four parts, nothing else. No boilerplate headings, no restating the diff, no checklists:
@@ -2802,7 +2802,32 @@ Lands before the load path and the resolver because both call into it.
   Task 11 calls `queue_dependency_notice()`; Task 12 calls `queue_merge_notice()` and `queue_conflict_notice()`; Task 14 extends this interface.
 
 **Design notes:**
-- Transient `"{$hook_prefix}_plugin_absorber_notices"`, no expiry, so the queue survives the resolver's `wp_safe_redirect()` and renders on the next admin load.
+- Option `"{$hook_prefix}_plugin_absorber_notices"`, so the queue survives the resolver's `wp_safe_redirect()` and renders on the next admin load.
+
+> **Deviations, deliberate (added 2026-08-03, from the PR 10 review):**
+>
+> 1. **An option, not a transient.** Verified in core: `set_transient()` short-circuits to
+>    `wp_cache_set()` and never writes the database when an external object cache is present. On a
+>    Redis or Memcached site the queue would exist only in the cache, and `wp_cache_flush()` — run
+>    by deploy scripts and every "purge cache" button — destroys it. The merge notice is raised
+>    once and never re-queued, so losing it means the site owner is never told. This queue is not
+>    a cache. See the amended Global Constraint.
+> 2. **Network options on multisite.** The resolver passes `$network_wide` to
+>    `deactivate_plugins()`, which removes the plugin from every site in the network. A per-site
+>    option would have parked the explanation in whichever site's options table happened to serve
+>    the request that triggered it — invisible to the superadmin, on one of fifty sites.
+> 3. **`render()` checks `activate_plugins` first.** Rendering *consumes* the queue, so without a
+>    gate any logged-in user loading `profile.php` would silently swallow the one warning an
+>    administrator was going to get. On multisite this correctly resolves to superadmins, since
+>    `activate_plugins` maps through `manage_network_plugins` there.
+> 4. **`all_admin_notices`, not `admin_notices`** (see Task 11). The three notice hooks are
+>    mutually exclusive branches in `admin-header.php`, and `admin_notices` does not fire in the
+>    network admin — exactly where a network-wide deactivation would be noticed.
+> 5. **`get_conflict_notice_message( $default )` replaces the planned private `message_or_default()`
+>    helper**, using the parameter added to `Sub_Plugin` in PR 7. Identical semantics, one less
+>    duplicated method.
+> 6. **`get_queue()` drops non-string entries** rather than printing them, and writes the cleaned
+>    array back, so a corrupted queue heals on the next write.
 - Queue entries are keyed `"{$slug}:{$type}"`, not by slug alone. A sub-plugin can legitimately earn a merge notice at `plugins_loaded` @1 and a dependency notice at @2 in the same request; keying by slug alone would silently drop one.
 - Default messages live **here**, not in `Sub_Plugin`. `get_conflict_notice_message()` returns `''` when unconfigured (Task 7 asserts this), and each notice type supplies its own fallback sentence — so auto-deactivating a plugin can never leave the user with no explanation.
 
@@ -3249,7 +3274,7 @@ gh pr create --base 09-loader-resolve --title "Notice queue" --body 'What: the t
 Usage:
 
     Loader::notices()->queue_merge_notice( $sub_plugin );
-    Loader::notices()->render();   // hooked to admin_notices by boot()
+    Loader::notices()->render();   // hooked to all_admin_notices by boot()
 
     // Or supply your own copy:
     "conflict_notice_message" => static fn() => __( "Now bundled with Give.", "give" ),
@@ -3290,7 +3315,7 @@ redirect (queue with one instance, render with another).'
 
   Task 12 adds the `plugins_loaded` @1 hook to `boot()`; Task 13 adds the activation call to `load()`.
 
-**Design note:** `boot()` wires only the @2 load hook and `admin_notices` in this PR. The @1 conflict-resolution hook arrives in Task 12 with the resolver it delegates to — wiring a trampoline to a collaborator that does not exist yet would not run.
+**Design note:** `boot()` wires only the @2 load hook and `all_admin_notices` in this PR. The @1 conflict-resolution hook arrives in Task 12 with the resolver it delegates to — wiring a trampoline to a collaborator that does not exist yet would not run.
 
 - [ ] **Step 1: Cut the branch**
 
@@ -3519,7 +3544,7 @@ class LoaderBootTest extends WPTestCase {
 
 	public function tearDown(): void {
 		remove_all_actions( 'plugins_loaded' );
-		remove_all_actions( 'admin_notices' );
+		remove_all_actions( 'all_admin_notices' );
 		Loader::reset();
 		Config::reset();
 		parent::tearDown();
@@ -3548,7 +3573,7 @@ class LoaderBootTest extends WPTestCase {
 
 		Loader::boot();
 
-		$this->assertNotFalse( has_action( 'admin_notices', [ Loader::class, 'render_notices' ] ) );
+		$this->assertNotFalse( has_action( 'all_admin_notices', [ Loader::class, 'render_notices' ] ) );
 
 		set_current_screen( 'front' );
 	}
@@ -3595,7 +3620,11 @@ Append these methods, and extend `reset()` as shown at the end:
 		add_action( 'plugins_loaded', [ self::class, 'load_all' ], 2 );
 
 		if ( is_admin() ) {
-			add_action( 'admin_notices', [ self::class, 'render_notices' ] );
+			// all_admin_notices, not admin_notices. WordPress dispatches admin_notices,
+			// network_admin_notices and user_admin_notices as mutually exclusive branches, so a
+			// superadmin working in the network admin -- exactly where a network-wide
+			// deactivation gets noticed -- would never see the queue rendered.
+			add_action( 'all_admin_notices', [ self::class, 'render_notices' ] );
 		}
 	}
 
@@ -3747,7 +3776,7 @@ gh pr create --base 10-notices-queue --title "Loader boot and load path" --body
 Usage:
 
     Loader::register( [ ... ] );
-    Loader::boot();   // wires plugins_loaded @2 and admin_notices
+    Loader::boot();   // wires plugins_loaded @2 and all_admin_notices
 
     add_filter( "give/plugin_absorber/should_load", function ( $should_load, $sub_plugin ) {
         return $should_load;
@@ -5054,11 +5083,11 @@ Expected: FAIL — `Call to undefined method Nexcess\PluginAbsorber\Notices::fil
 	}
 ```
 
-And inside `boot()`'s `is_admin()` block, beside the existing `admin_notices` line:
+And inside `boot()`'s `is_admin()` block, beside the existing `all_admin_notices` line:
 
 ```php
 		if ( is_admin() ) {
-			add_action( 'admin_notices', [ self::class, 'render_notices' ] );
+			add_action( 'all_admin_notices', [ self::class, 'render_notices' ] );
 			add_filter( 'wp_admin_notice_markup', [ self::class, 'filter_activation_error_markup' ] );
 		}
 ```