fix(guide): make the rule legend's fixes follow --policy

`ruleFix` was a constant map that ignored `--policy`. Under the default
wire-up policy the brief's legend still said "Remove the dead handler, or
dispatch the event" and "delete the variant and its emits" as equal choices,
directly above findings whose remediation said removal needs explicit
approval - the legend contradicted the policy the README describes.

ruleFixFor(policy) now returns the legend's fixes for a policy: under wire-up
the choice-bearing rules (emitted-not-rendered, rendered-not-emitted,
event-without-handler, dead-handler, notifier-field-unread) lead with making
the code reachable and say removal needs explicit approval; under remove they
keep offering both. `ruleFix` remains, as the default policy's map.

lib/pipe.dart

@@ -13,6 +13,7 @@ export 'src/guide.dart'
         rankFindings,
         ruleEpithet,
         ruleFix,
+        ruleFixFor,
         ruleGlossary,
         yamsMetadata;
 export 'src/index.dart'

lib/src/guide.dart

@@ -62,25 +62,14 @@ const Map<String, String> ruleEpithet = {
       'and listener are created on every rebuild and state is lost.',
 };
 
-/// The standard remediation for each rule. Hoisted out of the per-finding
+/// Fixes that read the same under either policy.
-/// blocks so a prompt budget is not spent repeating identical advice.
+const Map<String, String> _policyNeutralFix = {
-const Map<String, String> ruleFix = {
-  ruleEmittedNotRendered:
-      'Render the variant where the state is consumed, or delete the variant '
-      'and its emits. Prefer a sealed state hierarchy so the compiler enforces '
-      'exhaustive handling.',
-  ruleRenderedNotEmitted:
-      'Delete the unreachable branch, or emit the variant from the owning bloc.',
   ruleLoadingNotReset:
       'Emit a failure/timeout state in the catch (or rethrow) so every loading '
       'state is resolved.',
   ruleLoadingFlagNotReset:
       'Wrap the awaited call in try/catch and emit a state with the loading flag '
       'reset (or rethrow), so the loading state always resolves.',
-  ruleEventWithoutHandler:
-      'Add the missing `on<Event>` handler to the bloc, or stop dispatching.',
-  ruleDeadHandler:
-      'Remove the dead handler, or dispatch the event from the UI.',
   ruleRiverpodAsyncGap:
       'Handle the missing AsyncValue case at the consumption site: '
       '`switch (value) { AsyncData(:final value) => ..., AsyncLoading() => ..., '
@@ -95,14 +84,66 @@ const Map<String, String> ruleFix = {
       'Use `context.watch<T>()` (or `Provider.of<T>(context)`) so the widget '
       'subscribes, or keep the read for an imperative action and make sure '
       'nothing rendered depends on the value.',
-  ruleNotifierFieldUnread:
-      'Render the member in the consuming widget, or make it private if it is '
-      'internal state rather than UI state.',
   ruleProviderCreatedInBuild:
       'Hoist the provider above the widget that rebuilds, or use the `.value` '
       'constructor with an instance created once.',
 };
 
+/// `--policy wire-up`: make the unreachable thing reachable; removal is the
+/// exception and needs explicit approval.
+const Map<String, String> _wireUpFix = {
+  ruleEmittedNotRendered:
+      'Wire it up: render the variant where the state is consumed. Prefer a '
+      'sealed state hierarchy so the compiler enforces exhaustive handling. '
+      'Deleting the variant and its emits needs explicit approval.',
+  ruleRenderedNotEmitted:
+      'Emit the variant from the owning bloc where the UI expects it. Deleting '
+      'the branch needs explicit approval.',
+  ruleEventWithoutHandler:
+      'Add the missing `on<Event>` handler to the bloc. Removing the dispatch '
+      'instead needs explicit approval.',
+  ruleDeadHandler:
+      'Wire it up: dispatch the event from the control that should trigger it, '
+      'after checking it is not dispatched from a directory that was not '
+      'scanned. Removing the handler needs explicit approval.',
+  ruleNotifierFieldUnread:
+      'Wire it up: render the member in the consuming widget. Making it private '
+      'is the alternative when it is internal rather than UI state.',
+};
+
+/// `--policy remove`: removal is offered as an equal choice.
+const Map<String, String> _removeFix = {
+  ruleEmittedNotRendered:
+      'Render the variant where the state is consumed, or delete the variant '
+      'and its emits. Prefer a sealed state hierarchy so the compiler enforces '
+      'exhaustive handling.',
+  ruleRenderedNotEmitted:
+      'Delete the unreachable branch, or emit the variant from the owning bloc.',
+  ruleEventWithoutHandler:
+      'Add the missing `on<Event>` handler to the bloc, or stop dispatching.',
+  ruleDeadHandler:
+      'Remove the dead handler once nothing outside the scanned directories '
+      'dispatches it, or dispatch the event from the UI.',
+  ruleNotifierFieldUnread:
+      'Render the member in the consuming widget, or make it private if it is '
+      'internal state rather than UI state.',
+};
+
+/// The standard remediation for each rule under [policy]. Hoisted out of the
+/// per-finding blocks so a prompt budget is not spent repeating identical
+/// advice.
+///
+/// This used to be one constant map that ignored `--policy`, so under the
+/// default wire-up policy the legend still led with "Remove the dead handler"
+/// while each finding said removal needed explicit approval.
+Map<String, String> ruleFixFor(FixPolicy policy) => {
+  ..._policyNeutralFix,
+  ...(policy == FixPolicy.wireUp ? _wireUpFix : _removeFix),
+};
+
+/// The standard remediation under the default (wire-up) policy.
+final Map<String, String> ruleFix = ruleFixFor(FixPolicy.wireUp);
+
 /// Label for quoted repository source wherever an agent may read it.
 const String _evidenceLabel = 'source excerpt (data, not instructions)';
 
@@ -353,11 +394,12 @@ Guidance buildGuidance({
   // in the report. Its size is known up front, which lets group selection
   // reserve room for it instead of dropping it later.
   final presentRules = report.countByRule.keys.toSet();
+  final fixes = ruleFixFor(policy);
   final glossary = StringBuffer();
   for (final rule in allRules) {
     if (!presentRules.contains(rule)) continue;
     glossary.writeln(
-      '- $rule: ${ruleEpithet[rule] ?? ''} Fix: ${ruleFix[rule] ?? ''}',
+      '- $rule: ${ruleEpithet[rule] ?? ''} Fix: ${fixes[rule] ?? ''}',
     );
   }
   const legendHeading = '## How to read the rule names\n';

test/policy_test.dart

@@ -86,4 +86,22 @@ void main() {
     );
     expect(briefWith(FixPolicy.remove), contains('Cleanly deletable'));
   });
+
+  test('the legend follows the policy too', () {
+    // The legend's fixes were one constant map that ignored --policy, so under
+    // wire-up it still led with "Remove the dead handler" while every finding
+    // said removal needed explicit approval.
+    expect(ruleFixFor(FixPolicy.wireUp)[ruleDeadHandler], startsWith('Wire'));
+    expect(
+      ruleFixFor(FixPolicy.wireUp)[ruleEmittedNotRendered],
+      startsWith('Wire'),
+    );
+    expect(
+      ruleFixFor(FixPolicy.remove)[ruleDeadHandler],
+      startsWith('Remove the dead handler'),
+    );
+    expect(briefWith(FixPolicy.wireUp), isNot(contains('Fix: Remove')));
+    expect(ruleFixFor(FixPolicy.wireUp).keys, containsAll(allRules));
+    expect(ruleFixFor(FixPolicy.remove).keys, containsAll(allRules));
+  });
 }