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/ToneEngine.dart

@@ -0,0 +1,117 @@
+import '../about/internal/application/EscalationTier.dart';
+import '../about/internal/application/Standing.dart';
+import '../about/internal/application/ToneLevel.dart';
+
+/// All user-facing enforcement copy comes from here, so the hard cap is
+/// enforceable in one place: language may criticise behaviour, never the
+/// person. Nothing that mocks the user's worth ships.
+class ToneEngine {
+  /// The escalation ladder. Disappointment is deliberately placed above anger
+  /// because it works better as a lever.
+  static EscalationTier tierFor(int unacknowledgedCount) {
+    if (unacknowledgedCount <= 0) {
+      return EscalationTier.Reminder;
+    }
+    if (unacknowledgedCount == 1) {
+      return EscalationTier.Nudge;
+    }
+    if (unacknowledgedCount == 2) {
+      return EscalationTier.Nag;
+    }
+    if (unacknowledgedCount == 3) {
+      return EscalationTier.Disappointed;
+    }
+    return EscalationTier.Cold;
+  }
+
+  /// Notification body for a commitment at a given tier and tone.
+  static String nudge(
+    EscalationTier tier,
+    ToneLevel tone,
+    String title,
+  ) {
+    switch (tier) {
+      case EscalationTier.Reminder:
+        return "$title is due now.";
+      case EscalationTier.Nudge:
+        return "$title is still sitting there.";
+      case EscalationTier.Nag:
+        return tone == ToneLevel.Firm
+            ? "$title is overdue. It needs a decision."
+            : "Third time: $title. Do it or abandon it.";
+      case EscalationTier.Disappointed:
+        return "You said you would do $title. You have not.";
+      case EscalationTier.Cold:
+        return "$title. No more reminders about this one.";
+    }
+  }
+
+  /// The header copy on app open, which shifts with standing.
+  static String standingHeadline(Standing standing, ToneLevel tone) {
+    switch (standing) {
+      case Standing.Good:
+        return "You are in good standing.";
+      case Standing.Warned:
+        return "You are slipping.";
+      case Standing.Grounded:
+        return tone == ToneLevel.Firm
+            ? "You are grounded until this is cleared."
+            : "Grounded. Nothing new until the queue is empty.";
+      case Standing.Lockdown:
+        return "Lockdown. One item at a time.";
+    }
+  }
+
+  static String standingBody(Standing standing, ToneLevel tone) {
+    switch (standing) {
+      case Standing.Good:
+        return "Keep the plan honest and it stays this way.";
+      case Standing.Warned:
+        return "New electives are blocked. Clear some debt before adding more.";
+      case Standing.Grounded:
+        return "Your plans are hidden. This is what is actually outstanding.";
+      case Standing.Lockdown:
+        return "Complete or abandon each item below. There is no third option.";
+    }
+  }
+
+  /// Praise is rationed but real. A parent who only criticises gets tuned out —
+  /// this returns empty unless something specific was genuinely earned.
+  static String praise(String specificAchievement) {
+    if (specificAchievement.isEmpty) {
+      return "";
+    }
+    return specificAchievement;
+  }
+
+  /// The register the app switches to when distress is detected. The strict
+  /// persona drops entirely — this is the difference between a product people
+  /// keep and one they resent.
+  static String distressHeadline() {
+    return "Let us cut this back.";
+  }
+
+  static String distressBody() {
+    return "Something has clearly been hard lately. Pick three things that "
+        "genuinely matter this week and let the rest go. Nothing here is "
+        "counting against you right now.";
+  }
+
+  /// Copy shown when a deferral is refused because the cap is spent.
+  static String deferralRefused(int maxDeferrals) {
+    return "This has been deferred $maxDeferrals times. It can now only be "
+        "completed or abandoned.";
+  }
+
+  /// Copy shown when a non-negotiable deferral is attempted.
+  static String nonNegotiableRefused() {
+    return "Non-negotiables are not deferrable. That is what makes them "
+        "non-negotiable.";
+  }
+
+  /// Copy shown when the excuse is too short.
+  static String excuseTooShort(int minimum) {
+    return "Write at least $minimum characters. If it is not worth explaining, "
+        "it is not worth deferring.";
+  }
+}