Fix billing data integrity, sale atomicity and stock safety

Bills were persisted correctly but read back wrong. The read path rebuilt a
cart from its lines alone, dropping bill-level discounts and loyalty, so every
figure derived from a stored bill was overstated: the upload payload, the day
archive and the shift report. A discounted 529 bill read back as 620.

Money and data integrity
- order_dao: restore bill_discount and points_redeemed when rebuilding a cart;
  keep the reconstruction tier-less so the membership discount is not applied
  twice. Trust the recorded total and points via SaleTransaction.storedTotal.
- checkout_sale + order_dao.commitSale: write the bill, its stock movement and
  the loyalty update in one transaction. Previously a failure part-way through
  left a persisted bill the cashier believed had failed, inviting a duplicate.
- checkout_sale: re-check every line against live stock. A parked bill resumed
  after its stock was sold passed validation and oversold.
- catalogue_dao: allocate the invoice sequence in one transaction; the previous
  read-modify-write could hand two sales the same number and fail UNIQUE.
- local_store: replay unsynced sales after a catalogue import, so a mid-shift
  re-import cannot restore stock that has already been sold.
- payment_controller: stamp the signed-in operator on the bill instead of the
  hardcoded seed session, and pass the terminal id through.
- cart: reconcile per-slab GST against the bill total so the parts sum to the
  whole on a tax invoice.

Sync and reporting
- sync_repository: drain unsynced bills in a loop rather than silently capping
  at one page; stop on rejection so rejected rows cannot loop forever.
- sync_log_dao (new): persist the sync history to the sync_log table, which the
  schema already defined but nothing used. It was in memory, so the only record
  that bills had been uploaded died at restart.
- Scope shift reports by cashier. day_archive is re-keyed to
  (business_date, cashier_name) so a till stays settleable after its bills are
  uploaded and deleted. Schema v4 with a migration that carries v3 rows across.

Input and UI
- barcode_service: consume machine-paced keystrokes so a scan cannot also land
  in the focused field, and raise the bar to 60ms/char while a text field has
  focus so typing a mobile number is not read as a scan. Clock and focus check
  injected so the behaviour is testable.
- primary_button: make the label flexible; label plus trailing total overflowed
  the Charge button by up to 131px.
- app_router: redirect instead of null-casting when the receipt route is
  entered without its transaction.
- customer_repository: reduce the search query to digits so a punctuated mobile
  number matches.

Cleanup
- Remove TransactionRepository.save, CustomerRepository.recordSale and
  OrderDao.insertOrder, all superseded by commitSale.
- dart fix across the tree; 251 analyzer issues down to 3 info-level.

Tests: 23 passing / 15 failing -> 90 passing. Fixed the two defects that broke
the existing suite (containsAll type argument, reset() needing a catalogue) and
deleted the leftover template test. Added coverage for the order round trip,
the day archive after a real sync, stock safety, checkout atomicity, the v3->v4
migration, scanner-versus-human input, and an app-level smoke test that renders
every module.

Note: bills already uploaded with a discount went up overstated. This stops it
happening again but does not correct historical server data.

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

lib/domain/entities/cart.dart

@@ -174,11 +174,29 @@ class Cart extends Equatable {
   double get taxableAmount => (netAmount - taxAmount).asMoney;
 
   /// GST broken out per slab — required on a compliant tax invoice.
+  ///
+  /// The slabs are reconciled against [taxAmount] before being returned.
+  /// Rounding each slab on its own leaves the parts summing to a paisa either
+  /// side of the total printed on the same bill, which a tax invoice cannot
+  /// show; the residue is absorbed by the largest slab.
   Map<double, double> get taxBreakdown {
-    final map = <double, double>{};
+    final raw = <double, double>{};
     for (final line in lines) {
       final rate = line.product.gstRate;
-      map[rate] = ((map[rate] ?? 0) + line.taxAmount * _billFactor).asMoney;
+      raw[rate] = (raw[rate] ?? 0) + line.taxAmount * _billFactor;
+    }
+    if (raw.isEmpty) return const {};
+
+    final map = {
+      for (final e in raw.entries) e.key: e.value.asMoney,
+    };
+
+    final drift =
+        (taxAmount - map.values.fold(0.0, (a, b) => a + b)).asMoney;
+    if (drift != 0) {
+      final largest =
+          raw.entries.reduce((a, b) => a.value >= b.value ? a : b).key;
+      map[largest] = (map[largest]! + drift).asMoney;
     }
     return map;
   }

lib/domain/entities/customer.dart

@@ -1,6 +1,7 @@
 import 'package:equatable/equatable.dart';
 
 import '../../core/constants/app_constants.dart';
+import '../../core/utils/extensions.dart';
 
 enum Gender {
   male('Male'),
@@ -93,6 +94,26 @@ class Customer extends Equatable {
     return dob.month == now.month && dob.day == now.day;
   }
 
+  /// The shopper as they stand after a completed sale.
+  ///
+  /// Pure, so the caller can compute the new row and persist it in the same
+  /// transaction as the bill rather than as a separate write that might fail
+  /// on its own.
+  Customer applySale({
+    required double amount,
+    required int pointsEarned,
+    required int pointsRedeemed,
+    DateTime? at,
+  }) {
+    return copyWith(
+      loyaltyPoints:
+          (loyaltyPoints - pointsRedeemed + pointsEarned).clamp(0, 1 << 31),
+      lifetimeSpend: (lifetimeSpend + amount).asMoney,
+      visitCount: visitCount + 1,
+      lastVisitAt: at ?? DateTime.now(),
+    );
+  }
+
   Customer copyWith({
     String? name,
     String? email,

lib/domain/entities/shift_report.dart

@@ -88,7 +88,7 @@ class ShiftReport extends Equatable {
             t.status == TransactionStatus.completed &&
             t.createdAt.year == businessDate.year &&
             t.createdAt.month == businessDate.month &&
-            t.createdAt.day == businessDate.day)
+            t.createdAt.day == businessDate.day,)
         .toList()
       ..sort((a, b) => a.createdAt.compareTo(b.createdAt));
 
@@ -111,7 +111,7 @@ class ShiftReport extends Equatable {
           completed.fold(0.0, (s, t) => s + t.cart.taxAmount).asMoney,
       discountGiven: completed
           .fold(0.0,
-              (s, t) => s + t.cart.billDiscountTotal + t.cart.lineDiscountTotal)
+              (s, t) => s + t.cart.billDiscountTotal + t.cart.lineDiscountTotal,)
           .asMoney,
       roundOff: completed.fold(0.0, (s, t) => s + t.cart.roundOff).asMoney,
       paymentBreakdown: byMethod,

lib/domain/entities/transaction.dart

@@ -70,6 +70,8 @@ class SaleTransaction extends Equatable {
     required this.cashierName,
     this.status = TransactionStatus.completed,
     this.terminalId = 'TERM-01',
+    this.storedTotal,
+    this.storedPointsEarned,
   });
 
   final String id;
@@ -81,9 +83,20 @@ class SaleTransaction extends Equatable {
   final TransactionStatus status;
   final String terminalId;
 
+  /// The figure actually charged, as recorded at sale time.
+  ///
+  /// Set only when a bill is read back from storage. Deriving the total from
+  /// [cart] is correct for a live sale, but a rehydrated cart is a
+  /// reconstruction — if it ever loses a component the money must not move with
+  /// it. The recorded value wins whenever there is one.
+  final double? storedTotal;
+
+  /// Points issued by this sale, as recorded at sale time. See [storedTotal].
+  final int? storedPointsEarned;
+
   Customer? get customer => cart.customer;
 
-  double get total => cart.grandTotal;
+  double get total => storedTotal ?? cart.grandTotal;
 
   double get amountPaid =>
       payments.fold(0.0, (sum, p) => sum + p.amount).asMoney;
@@ -101,7 +114,7 @@ class SaleTransaction extends Equatable {
 
   bool get isSplit => payments.length > 1;
 
-  int get pointsEarned => cart.pointsEarned;
+  int get pointsEarned => storedPointsEarned ?? cart.pointsEarned;
   int get pointsRedeemed => cart.pointsRedeemed;
 
   String get paymentSummary =>

lib/domain/repositories/customer_repository.dart

@@ -11,12 +11,6 @@ abstract class CustomerRepository {
   Future<Customer> update(Customer customer);
 
   /// Applies loyalty and lifetime-spend changes once a sale completes.
-  Future<Customer> recordSale({
-    required String customerId,
-    required double amount,
-    required int pointsEarned,
-    required int pointsRedeemed,
-  });
 
   Future<List<Customer>> search(String query);
 

lib/domain/repositories/sync_repository.dart

@@ -62,9 +62,13 @@ abstract class SyncRepository {
   Future<List<SaleTransaction>> unsyncedOrders();
 
   /// Today's trading totals, read back from SQLite.
+  ///
+  /// Terminal-wide by default. Set [scopeToCashier] to cover only the bills
+  /// [cashierName] rang — what a till is actually settled against.
   Future<ShiftReport> todayReport({
     required String terminalId,
     required String cashierName,
+    bool scopeToCashier = false,
   });
 
   /// End-of-day step — uploads pending orders and flips the accepted ones to

lib/domain/repositories/transaction_repository.dart

@@ -1,7 +1,17 @@
+import '../entities/customer.dart';
 import '../entities/transaction.dart';
 
 abstract class TransactionRepository {
-  Future<SaleTransaction> save(SaleTransaction transaction);
+  /// Persists a completed sale as one atomic unit.
+  ///
+  /// The bill, the stock it consumed and the shopper's loyalty movement either
+  /// all land or none do, so a failure part-way through can never leave a
+  /// persisted bill that the cashier believes failed.
+  Future<void> commitSale({
+    required SaleTransaction transaction,
+    required Map<String, double> stockMovements,
+    Customer? updatedCustomer,
+  });
 
   Future<List<SaleTransaction>> history({int limit = 50});
 

lib/domain/usecases/checkout_sale.dart

@@ -51,10 +51,33 @@ class CheckoutSale {
     required Cart cart,
     required List<PaymentSplit> payments,
     required String cashierName,
+    String terminalId = 'TERM-01',
   }) async {
     _validate(cart, payments);
+    await _assertStockAvailable(cart);
 
     final now = DateTime.now();
+
+    // The shopper's new balance is computed before anything is written, so it
+    // can be persisted in the same transaction as the bill.
+    Customer? updatedCustomer;
+    final customer = cart.customer;
+    if (customer != null) {
+      final current = await _customers.findById(customer.id);
+      if (current == null) {
+        throw const CheckoutFailure(
+          'This customer is no longer on file. Remove them from the bill to '
+          'continue.',
+        );
+      }
+      updatedCustomer = current.applySale(
+        amount: cart.grandTotal,
+        pointsEarned: cart.pointsEarned,
+        pointsRedeemed: cart.pointsRedeemed,
+        at: now,
+      );
+    }
+
     final sequence = await _transactions.nextInvoiceSequence();
 
     final transaction = SaleTransaction(
@@ -64,24 +87,16 @@ class CheckoutSale {
       payments: payments,
       createdAt: now,
       cashierName: cashierName,
+      terminalId: terminalId,
     );
 
-    await _transactions.save(transaction);
-
-    await _products.decrementStock({
-      for (final line in cart.lines) line.product.id: line.quantity,
-    });
-
-    Customer? updatedCustomer;
-    final customer = cart.customer;
-    if (customer != null) {
-      updatedCustomer = await _customers.recordSale(
-        customerId: customer.id,
-        amount: cart.grandTotal,
-        pointsEarned: cart.pointsEarned,
-        pointsRedeemed: cart.pointsRedeemed,
-      );
-    }
+    await _transactions.commitSale(
+      transaction: transaction,
+      stockMovements: {
+        for (final line in cart.lines) line.product.id: line.quantity,
+      },
+      updatedCustomer: updatedCustomer,
+    );
 
     return CheckoutResult(
       transaction: transaction,
@@ -89,6 +104,29 @@ class CheckoutSale {
     );
   }
 
+  /// Re-checks every line against live stock.
+  ///
+  /// [CartLine.exceedsStock] reads the product snapshot taken when the item was
+  /// added, which goes stale the moment anything else sells the same item — a
+  /// parked bill resumed after its stock was sold would otherwise pass
+  /// validation and oversell.
+  Future<void> _assertStockAvailable(Cart cart) async {
+    for (final line in cart.lines) {
+      final live = await _products.findById(line.product.id);
+      if (live == null) {
+        throw CheckoutFailure(
+          '${line.product.name} is no longer in the catalogue.',
+        );
+      }
+      if (line.quantity > live.stock) {
+        throw CheckoutFailure(
+          'Only ${live.stock.toStringAsFixed(0)} ${live.unit.symbol} of '
+          '${live.name} in stock.',
+        );
+      }
+    }
+  }
+
   void _validate(Cart cart, List<PaymentSplit> payments) {
     if (cart.isEmpty) {
       throw const CheckoutFailure('Add at least one item before charging.');