feat(log): replay persisted logs in the viewer and flush on background

The log screen now replays the last 24 hours from the logs table into
Talker's history on open, so it covers the launch that crashed instead of
only the current session; lines are skipped by timestamp when memory
already reaches back. App lifecycle flushes the write buffer at
backgrounding, the moment a kill is most likely.

Author: whes1015

lib/app/app.dart

@@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:dpip/app/router/app_router.dart';
 import 'package:dpip/app/router/notification_routes.dart';
 import 'package:dpip/app/theme/app_theme.dart';
@@ -159,6 +161,12 @@ class _AppServicesHostState extends State<_AppServicesHost>
     // warm foreground is the reliable re-arm point. (The monitor handles the
     // foreground reporter + town on resume.)
     if (state == AppLifecycleState.resumed && _ready) _armBackground();
+    // Going to the background is the moment the process is most likely to be
+    // killed, and the buffered log lines are exactly what would explain why.
+    if (state == AppLifecycleState.paused ||
+        state == AppLifecycleState.detached) {
+      unawaited(Log.flush());
+    }
   }
 
   /// Resolves the current township and starts reporting — but only when

lib/features/log/presentation/pages/log_page.dart

@@ -1,14 +1,19 @@
+import 'dart:async';
+
 import 'package:dpip/core/logging/log.dart';
+import 'package:dpip/core/logging/log_store.dart';
 import 'package:dpip/l10n/gen/app_localizations.dart';
 import 'package:flutter/material.dart';
 import 'package:talker_flutter/talker_flutter.dart';
 
-/// In-app log viewer, backed by the shared [Log] history. Reachable from the
-/// More tab; pushed as a full-screen route.
+/// In-app log viewer. Reachable from the More tab; pushed as a full-screen
+/// route.
 ///
-/// Applies a 7-day retention window on open: the in-memory history isn't
-/// persisted across launches and is otherwise bounded only by count, so opening
-/// the screen drops anything older than a week.
+/// Shows Talker's live view of *this* session, and on open replays the last 24
+/// hours from the `logs` table into it — so the screen covers the launch that
+/// crashed, not just the one you are looking at. The replay happens once per
+/// visit and is skipped when the history already reaches back that far, which
+/// is the common case for a session that has been running a while.
 class LogPage extends StatefulWidget {
   const LogPage({super.key});
 
@@ -20,7 +25,31 @@ class _LogPageState extends State<LogPage> {
   @override
   void initState() {
     super.initState();
-    Log.pruneOlderThan(const Duration(days: 7));
+    unawaited(_replayPersisted());
+  }
+
+  /// Pulls the persisted log into Talker's history, oldest first, so the
+  /// screen reads in the order things happened.
+  ///
+  /// Anything already in memory is skipped by timestamp: a session that has
+  /// been open all day would otherwise show every line twice.
+  Future<void> _replayPersisted() async {
+    final store = Log.store;
+    if (store == null) return;
+    // Flush first, or the newest lines — the ones the user came to read — are
+    // still sitting in the write buffer.
+    await store.flush();
+    final oldestInMemory = Log.talker.history.isEmpty
+        ? null
+        : Log.talker.history.first.time;
+    final stored = await store.recent(limit: 2000);
+    for (final entry in stored.reversed) {
+      if (oldestInMemory != null && !entry.time.isBefore(oldestInMemory)) {
+        continue;
+      }
+      Log.talker.logCustom(_PersistedLog(entry));
+    }
+    if (mounted) setState(() {});
   }
 
   @override
@@ -37,3 +66,35 @@ class _LogPageState extends State<LogPage> {
     );
   }
 }
+
+/// A replayed line, tagged so it is visibly from an earlier session rather
+/// than something that just happened.
+class _PersistedLog extends TalkerLog {
+  _PersistedLog(this.entry)
+    : super(entry.message, time: entry.time, stackTrace: null);
+
+  final StoredLog entry;
+
+  @override
+  String get title => entry.level;
+
+  @override
+  AnsiPen get pen => switch (entry.level) {
+    'error' || 'critical' => AnsiPen()..red(),
+    'warning' => AnsiPen()..yellow(),
+    'debug' => AnsiPen()..gray(),
+    _ => AnsiPen()..blue(),
+  };
+
+  @override
+  String generateTextMessage({
+    TimeFormat timeFormat = TimeFormat.timeAndSeconds,
+  }) {
+    return [
+      '[${entry.level}] ${entry.time.toIso8601String()}',
+      entry.message,
+      ?entry.error,
+      ?entry.stackTrace,
+    ].join('\n');
+  }
+}

test/core/logging/log_store_test.dart

@@ -0,0 +1,152 @@
+/// The persisted log: what it keeps, what it drops, and what it must not do.
+///
+/// Two properties matter more than the rest. It must **never throw** — a
+/// logger that can fail its caller turns a diagnostic into an outage, and it
+/// is called from error handlers where there is nowhere left to report to. And
+/// its retention must run on **write**, because retention that only runs when
+/// something reads the table is retention that never runs: nobody opens the
+/// log screen on the device that is filling up.
+library;
+
+import 'package:dpip/core/logging/log_store.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:sqflite_common_ffi/sqflite_ffi.dart';
+
+/// A fresh database per call — sqflite hands back the same handle for a
+/// repeated path, and `:memory:` is a path.
+Future<Database> _openMemory() => databaseFactoryFfi.openDatabase(
+  inMemoryDatabasePath,
+  options: OpenDatabaseOptions(singleInstance: false),
+);
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+  sqfliteFfiInit();
+
+  var clock = DateTime.utc(2026, 8, 15, 12);
+
+  Future<(LogStore, Database)> makeStore({int flushAt = 64}) async {
+    final db = await _openMemory();
+    await LogStore.createSchema(db);
+    return (LogStore(db, now: () => clock, flushAt: flushAt), db);
+  }
+
+  StoredLog line(String message, {String level = 'info', DateTime? at}) =>
+      StoredLog(time: at ?? clock, level: level, message: message);
+
+  setUp(() => clock = DateTime.utc(2026, 8, 15, 12));
+
+  test('a line survives a flush and reads back whole', () async {
+    final (store, _) = await makeStore();
+    store.add(
+      StoredLog(
+        time: clock,
+        level: 'error',
+        message: 'boom',
+        error: 'StateError: bad',
+        stackTrace: '#0 somewhere',
+      ),
+    );
+    await store.flush();
+
+    final stored = await store.recent();
+    expect(stored, hasLength(1));
+    expect(stored.single.message, 'boom');
+    expect(stored.single.level, 'error');
+    expect(stored.single.error, 'StateError: bad');
+    expect(stored.single.stackTrace, '#0 somewhere');
+  });
+
+  test('adding does not touch the database until a flush', () async {
+    final (store, _) = await makeStore();
+    store.add(line('buffered'));
+    expect(
+      await store.count(),
+      0,
+      reason: 'a log call must not cost a database round-trip',
+    );
+    await store.flush();
+    expect(await store.count(), 1);
+  });
+
+  test('a burst flushes itself without waiting for the timer', () async {
+    // A reconnect loop or a stack-trace storm should not sit in memory until
+    // the timer fires — that is the run most likely to end in a kill.
+    final (store, _) = await makeStore(flushAt: 4);
+    for (var i = 0; i < 4; i++) {
+      store.add(line('line $i'));
+    }
+    // The flush is scheduled synchronously by the fourth `add`.
+    await Future<void>.delayed(Duration.zero);
+    expect(await store.count(), 4);
+  });
+
+  test('anything past 24 hours is dropped, on write', () async {
+    final (store, _) = await makeStore();
+    store.add(line('old', at: clock.subtract(const Duration(hours: 25))));
+    store.add(line('edge', at: clock.subtract(const Duration(hours: 23))));
+    await store.flush();
+    // The prune runs inside the same transaction as the insert, so a line that
+    // is already too old never even lands.
+    expect((await store.recent()).map((e) => e.message), ['edge']);
+
+    // Two hours on, `edge` has aged out too — and it is the *write* that
+    // notices, not a reader. Nobody opens the log screen on the device that is
+    // filling up.
+    clock = clock.add(const Duration(hours: 2));
+    store.add(line('new'));
+    await store.flush();
+
+    final messages = (await store.recent()).map((e) => e.message).toList();
+    expect(messages, ['new']);
+  });
+
+  test('reads come back newest first', () async {
+    final (store, _) = await makeStore();
+    for (var i = 0; i < 3; i++) {
+      store.add(line('line $i', at: clock.add(Duration(minutes: i))));
+    }
+    await store.flush();
+    expect((await store.recent()).map((e) => e.message).toList(), [
+      'line 2',
+      'line 1',
+      'line 0',
+    ]);
+  });
+
+  test('a level filter narrows the read', () async {
+    final (store, _) = await makeStore();
+    store
+      ..add(line('fine'))
+      ..add(line('bad', level: 'error'));
+    await store.flush();
+    expect((await store.recent(level: 'error')).map((e) => e.message), ['bad']);
+  });
+
+  test('clear empties it', () async {
+    final (store, _) = await makeStore();
+    store.add(line('x'));
+    await store.flush();
+    await store.clear();
+    expect(await store.count(), 0);
+  });
+
+  test('a closed database is survived, not propagated', () async {
+    // The property that matters most: this is called from error handlers, and
+    // an exception here would replace a diagnostic with a crash.
+    final (store, db) = await makeStore();
+    await db.close();
+    store.add(line('after close'));
+    await expectLater(store.flush(), completes);
+    expect(await store.count(), 0);
+    expect(await store.recent(), isEmpty);
+    await expectLater(store.clear(), completes);
+    await expectLater(store.dispose(), completes);
+  });
+
+  test('flushing an empty buffer is a no-op', () async {
+    final (store, _) = await makeStore();
+    await expectLater(store.flush(), completes);
+    expect(await store.count(), 0);
+  });
+}