Build promos for real: engine, storage, editor, and application at the till

The Promo module was a mockup. Three hardcoded rows, a toggle that changed
nothing, and no promo code anywhere in lib/domain or lib/data. A cashier
looking at it would reasonably conclude promotions were running.

Engine (domain/services/promo_engine.dart)
- Five campaign types: percent or flat off the bill, percent off a category
  or a product, and buy-X-get-Y.
- Conditions: date range (inclusive of the closing day), days of the week,
  minimum bill value, and a cap on what a percentage can take off — without
  one an unusually large trolley gives away more than the campaign was costed
  for.
- Stacking is conservative by default. All stackable campaigns apply together;
  of the exclusive ones only the single best does, chosen by what it is worth
  to the shopper with priority breaking ties. Two percentages compounding
  produce a discount nobody signed off, and the shop finds out at the end of
  the month.
- The total is capped at the subtotal, so no combination of campaign, tier and
  manual discount can turn a sale into a payout.
- buy-X-get-Y counts whole groups only, and prices the free unit at what is
  actually being charged — a line already carrying a manual discount must not
  refund more than it took.

Kept out of Cart deliberately: Cart owns arithmetic that must never be wrong,
this owns policy a shop changes weekly.

Storage (schema v6, plus promos_json on orders at v7)
- Campaigns persist locally, because a shop mid-promotion with a dead line
  still has to honour the price on the shelf edge.
- A bill records the campaign name and the amount given, not a link to the
  row. A campaign edited or deleted later cannot change what a past sale
  shows, and a reprinted receipt still names what the shopper was given.
- On read-back the promo amounts are subtracted from the manual discount,
  because bill_discount already contains them. Restoring both at full value
  would discount the bill twice — the same shape as the bug that used to
  overstate synced totals.

At the till
- Every cart mutation re-evaluates, so a promo cannot survive the line that
  earned it being removed.
- A resumed parked bill is re-evaluated rather than restored: a campaign that
  has since ended must not be honoured because the bill was parked while it
  was running.
- Campaigns are named individually on the billing panel and the printed
  receipt, so a shopper who came in for an advertised offer can see it applied.

Editor
- Full CRUD, admin-only, with validation for the cases that would save happily
  and then silently never fire — a targeted campaign with no target, a
  percentage over 100, an end date before the start.

Tests: 199 -> 210. Covers each campaign type, the eligibility conditions, the
stacking rules, the impossible-to-go-negative guarantee, GST recomputation
against the reduced total, round-tripping, and the double-count guard.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

lib/domain/entities/cart.dart

@@ -4,6 +4,7 @@ import '../../core/constants/app_constants.dart';
 import '../../core/utils/extensions.dart';
 import 'customer.dart';
 import 'product.dart';
+import 'promo.dart';
 
 /// How a discount value should be interpreted.
 enum DiscountType { none, percentage, flat }
@@ -100,6 +101,7 @@ class Cart extends Equatable {
     this.billDiscount = Discount.none,
     this.pointsRedeemed = 0,
     this.note,
+    this.appliedPromos = const [],
   });
 
   final List<CartLine> lines;
@@ -108,6 +110,14 @@ class Cart extends Equatable {
   final int pointsRedeemed;
   final String? note;
 
+  /// Campaigns that fired on this bill.
+  ///
+  /// Resolved by `PromoEngine` and handed in, rather than computed here: which
+  /// campaigns exist is policy that changes weekly, and Cart owns arithmetic
+  /// that must never be wrong. Stored as amounts so a bill read back years
+  /// later shows what was actually given, not what today's rules would give.
+  final List<AppliedPromo> appliedPromos;
+
   static const Cart empty = Cart();
 
   bool get isEmpty => lines.isEmpty;
@@ -143,9 +153,17 @@ class Cart extends Equatable {
 
   double get manualBillDiscountAmount => billDiscount.amountOn(subtotal);
 
+  /// What the automatic campaigns took off.
+  double get promoDiscountAmount =>
+      appliedPromos.fold(0.0, (sum, p) => sum + p.amount).asMoney;
+
   /// All bill-level reductions combined.
+  ///
+  /// Clamped to the subtotal so no combination of tier, campaign and manual
+  /// discount can drive a bill below zero and turn a sale into a payout.
   double get billDiscountTotal =>
-      (membershipDiscountAmount + manualBillDiscountAmount)
+      (membershipDiscountAmount + manualBillDiscountAmount +
+              promoDiscountAmount)
           .clamp(0, subtotal)
           .toDouble()
           .asMoney;
@@ -240,6 +258,7 @@ class Cart extends Equatable {
     Discount? billDiscount,
     int? pointsRedeemed,
     String? note,
+    List<AppliedPromo>? appliedPromos,
   }) {
     return Cart(
       lines: lines ?? this.lines,
@@ -247,10 +266,11 @@ class Cart extends Equatable {
       billDiscount: billDiscount ?? this.billDiscount,
       pointsRedeemed: pointsRedeemed ?? this.pointsRedeemed,
       note: note ?? this.note,
+      appliedPromos: appliedPromos ?? this.appliedPromos,
     );
   }
 
   @override
   List<Object?> get props =>
-      [lines, customer, billDiscount, pointsRedeemed, note];
+      [lines, customer, billDiscount, pointsRedeemed, note, appliedPromos];
 }