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/utils/StandingEngine.dart

@@ -0,0 +1,91 @@
+import '../about/external/data/Commitment.dart';
+import '../about/internal/application/Standing.dart';
+import 'DebtEngine.dart';
+import 'Thresholds.dart';
+
+/// Standing is computed continuously and drives real consequences. It is
+/// derived, never set — there is no way to talk your way up a tier.
+class StandingEngine {
+  /// The standing implied by the current debt and the missed-non-negotiable
+  /// count. Sick mode never escalates: strictness must never be the response
+  /// to someone who is actually struggling.
+  static Standing evaluate(
+    double debtScore, {
+    int missedNonNegotiables = 0,
+    bool sickMode = false,
+    bool distressed = false,
+  }) {
+    if (sickMode || distressed) {
+      return Standing.Good;
+    }
+
+    if (debtScore >= Thresholds.lockdownThreshold) {
+      return Standing.Lockdown;
+    }
+
+    if (debtScore >= Thresholds.groundedThreshold ||
+        missedNonNegotiables >= Thresholds.nonNegotiableMissesForGrounded) {
+      return Standing.Grounded;
+    }
+
+    if (debtScore >= Thresholds.warnedThreshold) {
+      return Standing.Warned;
+    }
+
+    return Standing.Good;
+  }
+
+  /// Evaluate straight from the commitment list.
+  static Standing evaluateFor(
+    List<Commitment> commitments, {
+    bool sickMode = false,
+    bool distressed = false,
+    DateTime? now,
+  }) {
+    return evaluate(
+      DebtEngine.totalDebt(commitments, now: now),
+      missedNonNegotiables: DebtEngine.missedNonNegotiables(commitments),
+      sickMode: sickMode,
+      distressed: distressed,
+    );
+  }
+
+  /// Whether a new commitment of this class may be created right now.
+  static bool permitsNewCommitment(Standing standing, {bool elective = false}) {
+    if (elective) {
+      return canAddElectives(standing);
+    }
+    return canAddCommitments(standing);
+  }
+
+  /// Grounded replaces the home screen with the overdue queue — you do not get
+  /// to look at your nice plans, only at your mess.
+  static bool showsOverdueQueueAsHome(Standing standing) {
+    return standing == Standing.Grounded || standing == Standing.Lockdown;
+  }
+
+  /// Lockdown puts a blocking interstitial in front of the app that must be
+  /// cleared one item at a time.
+  static bool blocksAppOnOpen(Standing standing) {
+    return standing == Standing.Lockdown;
+  }
+
+  /// Whether the accountability partner is auto-notified at this tier.
+  static bool notifiesPartner(Standing standing) {
+    return standing == Standing.Grounded || standing == Standing.Lockdown;
+  }
+
+  /// Debt still to shed before dropping a tier. Zero when already at Good.
+  static double debtToNextTierDown(double debtScore, Standing standing) {
+    switch (standing) {
+      case Standing.Lockdown:
+        return debtScore - Thresholds.lockdownThreshold;
+      case Standing.Grounded:
+        return debtScore - Thresholds.groundedThreshold;
+      case Standing.Warned:
+        return debtScore - Thresholds.warnedThreshold;
+      case Standing.Good:
+        return 0;
+    }
+  }
+}