Initial commit: Grounded Flutter frontend

A to-do app that doesn't believe you — an enforcement layer rather than a
neutral ledger.

Architecture ported from Autoreceptives/Frontend/Receptive: stacked MVVM with
the mandatory 4-file screen pattern, one ParentViewModel owning the loading /
network / error overlays and the handleError decision tree, one AppDataManager
gateway, dio comms carrying the three identity headers, secure storage with
random-suffixed keys, and a single-chokepoint Navigator. Package root and Dart
package name are both Grounded; org is nya.

The enforcement engine, one unit per formula in utils/:

- DebtEngine      w(class) x severity(d) x decay(t), sublinear severity so old
                  misses cannot swamp the score; abandonment 2x with 30-day
                  decay immunity; late complete retains 30%
- StandingEngine  Good -> Warned -> Grounded -> Lockdown, derived not set;
                  Grounded replaces home with the overdue queue
- CapacityEngine  blocks over-scheduling against p50 of historically completed
                  minutes, with a learned per-category estimation multiplier
- IntegrityEngine session integrity, weekly volume, plyometric contact ceiling
                  and enforced recovery gaps
- ExcuseAnalyser  on-device excuse clustering plus the confrontation copy
- GuardrailEngine distress detection and rationed amnesty
- ToneEngine      all enforcement copy, so the tone cap lives in one place

CommitmentEvent is append-only and is the source of truth rather than the
status field, which is what makes honest history and excuse analysis possible.

Goals contain commitments via parentId, and a task can be run from a
full-screen runner that derives elapsed time from wall-clock so screen-off
cannot lose time. Backgrounding pauses the clock and is counted. The runner is
mirrored into an ongoing notification, with alarm-class full-screen intents
reserved for non-negotiables.

Design language, fonts, icon and native splash are in place; Mason bricks are
retargeted to this project and verified end-to-end.

flutter analyze lib/ reports no errors.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Mfu2gQLSFN21YRBcU2NrTt

frontend/lib/Grounded/see/training/ViewTraining.dart

@@ -0,0 +1,129 @@
+import '../../about/external/data/Program.dart';
+import '../../about/external/data/SessionLog.dart';
+import '../../about/external/data/SessionTemplate.dart';
+import '../../about/external/data/pages/request/HistoryRequest.dart';
+import '../../about/external/data/pages/request/PageAndSort.dart';
+import '../../about/external/data/pages/request/Pageable.dart';
+import '../../about/external/data/pages/request/Sort.dart';
+import '../../about/external/data/pages/response/SessionLogPage.dart';
+import '../../about/external/initial/IdRequest.dart';
+import '../../utils/IntegrityEngine.dart';
+import '../../utils/ObjectConvertors.dart';
+import '../parent/ParentViewModel.dart';
+import 'ConnectTraining.dart';
+
+class ViewTraining extends ParentViewModel {
+  ConnectTraining connection;
+
+  ViewTraining(super.context, this.connection);
+
+  void loadProgram() async {
+    if (!await hasNetwork(() => loadProgram())) return;
+
+    showLoading("Loading your program");
+
+    try {
+      final response = await getDataManager().getMyPrograms(HistoryRequest(
+        query: PageAndSort(
+          sort: Sort('desc', 'active'),
+          page: Pageable(0, 0, 20, 0),
+        ),
+      ));
+
+      final List<Program> programs = getProgramList(response.data);
+
+      final Program active = programs.firstWhere(
+        (item) => item.active,
+        orElse: () => programs.isEmpty ? Program() : programs.first,
+      );
+
+      await getDataManager().setActiveProgram(active);
+
+      final List<SessionTemplate> sessions = await _loadSessions(active);
+
+      closeLoading();
+
+      connection.onProgramLoaded(active, sessions);
+
+      loadHistory(active);
+    } catch (e) {
+      handleError(e, () => loadProgram(), () => dismissError(), "Retry");
+    }
+  }
+
+  Future<List<SessionTemplate>> _loadSessions(Program program) async {
+    if (program.id == null) {
+      return <SessionTemplate>[];
+    }
+
+    final response = await getDataManager()
+        .getProgramSessions(IdRequest(id: program.id ?? ""));
+
+    return getSessionTemplateList(response.data);
+  }
+
+  void loadHistory(Program program) async {
+    try {
+      final response = await getDataManager().getSessionHistory(HistoryRequest(
+        query: PageAndSort(
+          sort: Sort('desc', 'startedAt'),
+          page: Pageable(0, 0, 20, 0),
+        ),
+      ));
+
+      final SessionLogPage page = SessionLogPage.fromJson(response.data);
+
+      connection.onHistoryLoaded(page.content);
+
+      _checkLoadCeilings(program, page.content);
+    } catch (e) {
+      handleError(e, () => loadHistory(program), () => dismissError(), "Retry");
+    }
+  }
+
+  /// Plyometrics is the one modality where the app should stop you rather than
+  /// push you — CNS and connective tissue do not recover on a motivation
+  /// schedule.
+  void _checkLoadCeilings(Program program, List<SessionLog> history) {
+    final DateTime weekStart =
+        DateTime.now().subtract(Duration(days: DateTime.now().weekday - 1));
+
+    final List<SessionLog> thisWeek = history
+        .where((session) =>
+            session.startedAt != null &&
+            session.startedAt!.isAfter(weekStart))
+        .toList();
+
+    final int contacts = IntegrityEngine.weeklyContacts(thisWeek);
+
+    if (IntegrityEngine.contactCeilingBreached(
+        thisWeek, program.weeklyContactCeiling)) {
+      connection.onContactCeilingReached(
+          contacts, program.weeklyContactCeiling);
+      return;
+    }
+
+    _checkRecovery(program, history);
+  }
+
+  void _checkRecovery(Program program, List<SessionLog> history) {
+    // The most recent hard lower-body session gates the next one.
+    final List<SessionLog> hard = history
+        .where((session) => session.sessionRpe >= 8 && session.startedAt != null)
+        .toList();
+
+    if (hard.isEmpty) {
+      return;
+    }
+
+    final DateTime last = hard.first.startedAt!;
+
+    if (IntegrityEngine.recoveredEnough(last, program.lowerBodyRecoveryHours)) {
+      return;
+    }
+
+    final int elapsed = DateTime.now().difference(last).inHours;
+
+    connection.onRecoveryBlocked(program.lowerBodyRecoveryHours - elapsed);
+  }
+}