From c1b87dea5475c669bed77cd9dfb73c267db19359 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Thu, 22 Oct 2026 11:10:42 +0100 Subject: [PATCH] feat(app): dismiss recorded local chat notices in the thread Show dismissible notices for refused history reads, refused live watches and a running compaction. A dismissal lasts only while the recorded condition is unchanged; a syncToken gap hides pre-gap notices until fresh state arrives. --- .../chat/conversation/chat_thread_view.dart | 278 +++++++++++- app/lib/features/chat/domain/chat_notice.dart | 192 +++++++++ .../features/chat/domain/chat_transcript.dart | 6 +- .../chat/conversation/chat_notice_test.dart | 404 ++++++++++++++++++ 4 files changed, 865 insertions(+), 15 deletions(-) create mode 100644 app/lib/features/chat/domain/chat_notice.dart create mode 100644 app/test/features/chat/conversation/chat_notice_test.dart diff --git a/app/lib/features/chat/conversation/chat_thread_view.dart b/app/lib/features/chat/conversation/chat_thread_view.dart index 9e089695..b62ee07d 100644 --- a/app/lib/features/chat/conversation/chat_thread_view.dart +++ b/app/lib/features/chat/conversation/chat_thread_view.dart @@ -5,6 +5,7 @@ import 'package:flutter/material.dart'; import '../../../core/api_gateway.dart'; import '../domain/chat_activity_detail.dart'; +import '../domain/chat_notice.dart'; import '../domain/chat_transcript.dart'; import '../ui/sessions/chat_adaptive.dart'; import '../ui/transcript/chat_markdown_view.dart'; @@ -63,6 +64,25 @@ class _ChatThreadViewState extends State { late ChatComposerController _composer = _attachComposer(); late ChatRowKeys _rowKeys = ChatRowKeys(); + /// Local notices the operator hid; cleared when the conversation or socket + /// changes so a reconnect never keeps a stale dismissal. + ChatNoticeDismissals _dismissals = ChatNoticeDismissals(); + + /// True while a reconnect repair is in flight: notices recorded before the + /// gap are stale, so none is drawn until the repair reports fresh state. + bool _reconnecting = false; + int _syncGeneration = 0; + + /// The transcript held when the socket was replaced. A running state recorded + /// before the gap cannot be trusted again until a fresh read or frame + /// replaces that transcript. + List? _preGapMessages; + + /// The chain that repairs the newest socket gap. A second gap waits for an + /// in-flight repair instead of treating the controller's immediate return as + /// completion, which would expose stale notices mid-repair. + Future? _repair; + /// A sent turn shown before history or a live frame echoes it. final List _optimistic = []; @@ -132,9 +152,38 @@ class _ChatThreadViewState extends State { _controller = _attach(); _composer = _attachComposer(); _rowKeys = ChatRowKeys(); + _dismissals = ChatNoticeDismissals(); + _reconnecting = false; + _preGapMessages = null; + _syncGeneration++; _optimistic.clear(); } else if (oldWidget.syncToken != widget.syncToken) { - unawaited(_controller.resync()); + // The socket was replaced: conditions recorded before the gap are stale, + // so no earlier dismissal survives and nothing recorded before the gap is + // painted while the repair runs. + _dismissals.clear(); + _preGapMessages = _controller.messages; + _reconnecting = true; + final generation = ++_syncGeneration; + final previous = _repair; + final repair = (previous ?? Future.value()) + .then((_) async { + // A newer gap owns the repair; its own step in this chain runs next. + if (!mounted || generation != _syncGeneration) return; + await _controller.resync(); + }) + .whenComplete(() { + if (!mounted || generation != _syncGeneration) return; + setState(() { + _reconnecting = false; + // A successful repair replaced the transcript with fresh state. + if (!identical(_controller.messages, _preGapMessages)) { + _preGapMessages = null; + } + }); + }); + _repair = repair; + unawaited(repair); } } @@ -151,6 +200,7 @@ class _ChatThreadViewState extends State { builder: (context, _) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; + final messages = _visibleMessages(); final cards = chatCardRows( permissions: _controller.permissionFrames, forms: _controller.questionForms, @@ -162,7 +212,29 @@ class _ChatThreadViewState extends State { // not generating, so the transcript indicator and its live region stand // down; the composer's Stop control still follows `running`. final awaiting = cards.any(chatCardAwaitingOperator); - final rows = transcriptRows(_visibleMessages(), trailing: cards); + final allRows = transcriptRows(messages, trailing: cards); + // A transcript held from before a socket gap may still say a compaction is + // running even when the repair's read is refused. That running state is + // stale, so no compaction notice is derived from it until a fresh read or + // frame replaces the transcript. Fresh failure notices still report. + // + // Notices report recorded conditions only: a refused read/watch and a + // running compaction. A dismissal keeps one hidden until its condition + // changes. A running compaction's own activity line is that notice, so it + // is not drawn twice; hiding it when dismissed is the whole dismissal. + final allNotices = _reconnecting + ? const [] + : chatNotices( + historyError: _controller.error, + liveError: _controller.subscriptionError, + messages: _staleTranscript ? const [] : _controller.messages, + ); + final notices = _dismissals.visible(allNotices); + final compactionNotice = _noticeOf(notices, ChatNoticeKind.compaction); + final rows = [ + for (final row in allRows) + if (!_hiddenRunningCompaction(row)) row, + ]; // Older pages prepend messages and a live frame can append one, so a // folded assistant turn's first message id is not a stable identity. // ChatRowKeys carries a turn's key forward while it still holds any of @@ -170,6 +242,11 @@ class _ChatThreadViewState extends State { // across paging and streaming. final keys = _rowKeys.forRows(rows); final initialLoad = !_controller.loaded && _controller.loading; + final historyNotice = _noticeOf( + notices, + ChatNoticeKind.connectionRefused, + ); + final liveNotice = _noticeOf(notices, ChatNoticeKind.liveFailure); return Column( children: [ Expanded( @@ -230,21 +307,23 @@ class _ChatThreadViewState extends State { ), ), ), - if (_controller.error != null) - ChatErrorNotice( + if (historyNotice != null) + _ChatNoticeLine( key: const Key('chat-history-error'), - message: 'Chat history unavailable\n${_controller.error}', + notice: historyNotice, + onDismiss: _dismiss, onRetry: _controller.load, ), - if (_controller.subscriptionError != null) - ChatErrorNotice( + if (liveNotice != null) + _ChatNoticeLine( key: const Key('chat-live-error'), - message: - 'Live updates unavailable\n${_controller.subscriptionError}', + notice: liveNotice, + onDismiss: _dismiss, onRetry: _controller.resync, ), if (_controller.loaded && - rows.isEmpty && + allRows.isEmpty && + allNotices.isEmpty && _controller.error == null) const Padding( key: Key('chat-thread-empty'), @@ -255,7 +334,15 @@ class _ChatThreadViewState extends State { Padding( key: ValueKey(keys[index]), padding: const EdgeInsets.symmetric(horizontal: 16), - child: _transcriptRow(rows[index]), + child: _transcriptRow( + rows[index], + onDismissCompaction: + compactionNotice != null && + chatNoticeActivityCondition(rows[index]) == + compactionNotice.condition + ? () => _dismiss(compactionNotice) + : null, + ), ), if (_controller.running && !awaiting) Padding( @@ -279,9 +366,41 @@ class _ChatThreadViewState extends State { }, ); - Widget _transcriptRow(JsonMap row) { + ChatNotice? _noticeOf(List notices, ChatNoticeKind kind) { + for (final notice in notices) { + if (notice.kind == kind) return notice; + } + return null; + } + + /// Whether a running compaction's activity line must stay off screen. + /// + /// That line is the compaction notice, so it follows the same conditions: it + /// is hidden while the repair runs, while the held transcript is still the + /// pre-gap one, and when the operator dismissed this exact compaction. A + /// different running compaction in the transcript keeps its own line. + bool _hiddenRunningCompaction(JsonMap row) { + final condition = chatNoticeActivityCondition(row); + if (condition == null) return false; + return _reconnecting || + _staleTranscript || + _dismissals.isDismissed(condition); + } + + /// Whether the held transcript is still the one recorded before the gap. + bool get _staleTranscript => + _preGapMessages != null && + identical(_controller.messages, _preGapMessages); + + void _dismiss(ChatNotice notice) { + setState(() => _dismissals.dismiss(notice)); + } + + Widget _transcriptRow(JsonMap row, {VoidCallback? onDismissCompaction}) { final kind = '${row['kind'] ?? ''}'; - if (kind == 'activity') return _ChatActivityLine(row: row); + if (kind == 'activity') { + return _ChatActivityLine(row: row, onDismiss: onDismissCompaction); + } if (kind == 'permission' || kind == 'question') { return ChatTranscriptCard( row: row, @@ -312,6 +431,126 @@ class _ChatThreadViewState extends State { ); } +/// The native dismiss control shared by a local notice and a running +/// compaction's activity line. Material uses a tooltip; Cupertino carries the +/// same accessible name on the wrapping node, since its button has none. +Widget _noticeDismissControl({ + required bool cupertino, + required String label, + required Key key, + required VoidCallback onPressed, +}) { + final icon = Icon(cupertino ? CupertinoIcons.xmark_circle_fill : Icons.close); + if (!cupertino) { + return IconButton( + key: key, + tooltip: label, + onPressed: onPressed, + icon: icon, + ); + } + return Semantics( + container: true, + button: true, + label: label, + onTap: onPressed, + child: ExcludeSemantics( + child: CupertinoButton( + key: key, + padding: EdgeInsets.zero, + onPressed: onPressed, + child: icon, + ), + ), + ); +} + +/// One local failure notice beside the conversation. +/// +/// It is never a message bubble and never sent to the agent. The line carries +/// the kind's own words plus the recorded reason, keeps its native Retry and +/// adds a native dismiss control. Colour only repeats the failure state, so the +/// words remain readable without it. A running compaction is a recorded activity +/// line and is dismissed there instead. +class _ChatNoticeLine extends StatelessWidget { + const _ChatNoticeLine({ + super.key, + required this.notice, + required this.onDismiss, + this.onRetry, + }); + + final ChatNotice notice; + final ValueChanged onDismiss; + final VoidCallback? onRetry; + + @override + Widget build(BuildContext context) { + final cupertino = + chatControlsStyleOf(context) == ChatControlsStyle.cupertino; + final theme = Theme.of(context); + final color = cupertino + ? CupertinoColors.systemRed.resolveFrom(context) + : theme.colorScheme.error; + final style = + (cupertino + ? CupertinoTheme.of(context).textTheme.textStyle + : theme.textTheme.bodyMedium) + ?.copyWith(color: color); + final icon = cupertino + ? CupertinoIcons.exclamationmark_circle + : Icons.error_outline; + return Padding( + padding: const EdgeInsetsDirectional.fromSTEB(16, 4, 8, 4), + child: Column( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Row( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Padding( + padding: const EdgeInsetsDirectional.only(top: 8), + child: Icon(icon, color: color), + ), + const SizedBox(width: 8), + Expanded( + child: Padding( + padding: const EdgeInsets.symmetric(vertical: 8), + child: Semantics( + liveRegion: true, + child: Text(notice.text, style: style), + ), + ), + ), + _dismissControl(cupertino), + ], + ), + if (onRetry != null) + Align( + alignment: AlignmentDirectional.centerStart, + child: cupertino + ? CupertinoButton( + padding: EdgeInsets.zero, + onPressed: onRetry, + child: const Text('Retry'), + ) + : TextButton(onPressed: onRetry, child: const Text('Retry')), + ), + ], + ), + ); + } + + Widget _dismissControl(bool cupertino) { + return _noticeDismissControl( + cupertino: cupertino, + label: chatNoticeDismissLabel(notice.kind), + key: ValueKey('chat-notice-dismiss-${notice.kind.name}'), + onPressed: () => onDismiss(notice), + ); + } +} + /// One recorded activity line for a turn. /// /// The line is a summary of the recorded sequence. Its wording and state come @@ -321,10 +560,14 @@ class _ChatThreadViewState extends State { /// input, output, error, duration and edit diff; collapsing restores the single /// line without touching the turn. class _ChatActivityLine extends StatefulWidget { - const _ChatActivityLine({required this.row}); + const _ChatActivityLine({required this.row, this.onDismiss}); final JsonMap row; + /// Set only for a running compaction, whose line is the local notice the + /// operator can hide until that compaction's condition changes. + final VoidCallback? onDismiss; + @override State<_ChatActivityLine> createState() => _ChatActivityLineState(); } @@ -405,6 +648,13 @@ class _ChatActivityLineState extends State<_ChatActivityLine> { ), ), _toggleControl(cupertino), + if (widget.onDismiss != null) + _noticeDismissControl( + cupertino: cupertino, + label: chatNoticeDismissLabel(ChatNoticeKind.compaction), + key: const ValueKey('chat-notice-dismiss-compaction'), + onPressed: widget.onDismiss!, + ), ], ), if (_expanded) _detail(context, cupertino, secondary), diff --git a/app/lib/features/chat/domain/chat_notice.dart b/app/lib/features/chat/domain/chat_notice.dart new file mode 100644 index 00000000..27376cab --- /dev/null +++ b/app/lib/features/chat/domain/chat_notice.dart @@ -0,0 +1,192 @@ +import '../../../core/api_gateway.dart'; +import '../../../core/error_reason.dart'; +import 'chat_transcript.dart'; + +/// The local notices one conversation can record beside its messages. +/// +/// A notice is never a chat message and never reaches the agent. Each kind +/// reports one recorded condition; the thread stops showing it only while that +/// condition is unchanged (see [ChatNoticeDismissals]). +enum ChatNoticeKind { connectionRefused, liveFailure, compaction } + +/// The two failure labels already used by this conversation, kept verbatim so a +/// refused read/watch is never mistaken for an empty transcript. +const String chatConnectionRefusedLabel = 'Chat history unavailable'; +const String chatLiveFailureLabel = 'Live updates unavailable'; + +/// The running-phase words shared verbatim with the web's `turnPhaseLabel`. +const String chatCompactionLabel = chatCompactionPhaseLabel; + +/// The accessible name of each kind's dismiss control. The web names its local +/// notice control `Dismiss command notice`; these keep the same shape while +/// naming the condition the operator is hiding. +String chatNoticeDismissLabel(ChatNoticeKind kind) => switch (kind) { + ChatNoticeKind.connectionRefused => 'Dismiss connection notice', + ChatNoticeKind.liveFailure => 'Dismiss live updates notice', + ChatNoticeKind.compaction => 'Dismiss compaction notice', +}; + +/// One recorded local notice: what it is, which condition it reports and the +/// exact line the thread shows. +class ChatNotice { + const ChatNotice({ + required this.kind, + required this.condition, + required this.label, + this.detail = '', + }); + + final ChatNoticeKind kind; + + /// The recorded condition this notice reports. A different value is a new + /// notice even when the words repeat, and a dismissed value stays hidden only + /// while it is still recorded. + final String condition; + + /// The condition's label, in the app/web words for that kind. + final String label; + + /// The recorded reason, exactly as the web and the native client print it. + /// Empty for a phase with no reason (a running compaction). + final String detail; + + /// The line the transcript shows. The reason is the recorded one, never a + /// runtime diagnostic. + String get text => detail.isEmpty ? label : '$label\n$detail'; +} + +/// Build the notices for the conditions this thread currently records, in the +/// order the thread shows them: a refused read, a refused live watch, then a +/// running compaction. Nothing is invented: an absent condition adds no line. +List chatNotices({ + String? historyError, + String? liveError, + List messages = const [], +}) { + final notices = []; + final history = _failureDetail(historyError); + if (history != null) { + notices.add( + ChatNotice( + kind: ChatNoticeKind.connectionRefused, + condition: 'connection-refused\n$history', + label: chatConnectionRefusedLabel, + detail: history, + ), + ); + } + final live = _failureDetail(liveError); + if (live != null) { + notices.add( + ChatNotice( + kind: ChatNoticeKind.liveFailure, + condition: 'live-failure\n$live', + label: chatLiveFailureLabel, + detail: live, + ), + ); + } + final compaction = chatRunningCompaction(messages); + if (compaction != null) { + notices.add( + ChatNotice( + kind: ChatNoticeKind.compaction, + condition: chatCompactionCondition(compaction), + label: chatCompactionLabel, + ), + ); + } + return notices; +} + +/// The condition key of the compaction recorded as [id]. +String chatCompactionCondition(String id) => 'compaction\n$id'; + +/// The recorded reason without a Dart runtime prefix, or null when there is no +/// recorded failure. [describeErrorReason] is the shared rule; a failure that +/// carries no text still says the connection closed, as the web client does. +String? _failureDetail(String? error) { + if (error == null) return null; + return describeErrorReason(error, fallback: 'Connection closed'); +} + +/// The identity of the newest recorded compaction in [messages], or null unless +/// that compaction is still running. +/// +/// The winning record is the last one in transcript order, not the last running +/// one: a later terminal update supersedes an earlier running update. Otherwise +/// a stale id could keep a notice (and suppress the empty state) after the +/// transcript already reports the compaction ended. +String? chatRunningCompaction(List messages) { + JsonMap? latest; + for (final message in messages) { + if (message['role'] != 'assistant') continue; + for (final part in (message['parts'] as List? ?? const [])) { + if (part is! Map) continue; + final record = Map.from(part); + if (!chatActivityType(record)) continue; + if (chatActivityKind(record).toLowerCase() != 'compaction') continue; + latest = record; + } + } + if (latest == null) return null; + if (chatActivityState(latest).toLowerCase() != 'running') return null; + return '${latest['id'] ?? ''}'; +} + +/// The recorded condition of the running compaction that [row] presents, or +/// null when the row is not a running compaction's activity line. +/// +/// That line is the compaction notice drawn in place, not a second copy of it. +/// The view compares this with the notice's own [ChatNotice.condition], so a +/// dismissal hides the compaction the operator named, not every running +/// compaction in the transcript. +String? chatNoticeActivityCondition(JsonMap row) { + if ('${row['kind'] ?? ''}' != 'activity') return null; + final records = row['records']; + if (records is List && records.isNotEmpty) { + for (final record in records.reversed) { + if (record is! Map) continue; + final latest = Map.from(record); + if (chatActivityKind(latest).toLowerCase() != 'compaction') return null; + if (chatActivityState(latest).toLowerCase() != 'running') return null; + return chatCompactionCondition('${latest['id'] ?? ''}'); + } + return null; + } + // A caller-built row carries the same fields instead of records. + if (chatActivityKind(row).toLowerCase() != 'compaction') return null; + if (chatActivityState(row).toLowerCase() != 'running') return null; + return chatCompactionCondition('${row['id'] ?? ''}'); +} + +/// The operator's dismissals for one open conversation. +/// +/// A dismissal is keyed by the notice's recorded condition. It hides that +/// notice while the same condition stays recorded, and is forgotten as soon as +/// the condition is absent or changes — so a recurrence shows again. A +/// reconnect calls [clear], because a gap can leave an old dismissal behind. +class ChatNoticeDismissals { + final Set _dismissed = {}; + + /// The notices still shown, in order. Conditions that are no longer recorded + /// are pruned here, so a later recurrence is a new notice. + List visible(List notices) { + final recorded = {for (final notice in notices) notice.condition}; + _dismissed.retainAll(recorded); + return [ + for (final notice in notices) + if (!_dismissed.contains(notice.condition)) notice, + ]; + } + + /// Hide [notice] until its recorded condition changes. + void dismiss(ChatNotice notice) => _dismissed.add(notice.condition); + + /// Whether [condition] is currently hidden. Used for a running compaction's + /// own activity line, which is the same notice drawn in place. + bool isDismissed(String condition) => _dismissed.contains(condition); + + /// Forget every dismissal (a reconnect or a different conversation). + void clear() => _dismissed.clear(); +} diff --git a/app/lib/features/chat/domain/chat_transcript.dart b/app/lib/features/chat/domain/chat_transcript.dart index 8665d311..9d4c3394 100644 --- a/app/lib/features/chat/domain/chat_transcript.dart +++ b/app/lib/features/chat/domain/chat_transcript.dart @@ -137,11 +137,15 @@ String chatActivityState(JsonMap record) { return ''; } +/// The web's `Compacting context…` phase words. Both this activity line and the +/// local compaction notice use this one constant, so their wording cannot drift. +const String chatCompactionPhaseLabel = 'Compacting context…'; + /// The running-phase words shared verbatim with the web's `turnPhaseLabel`. /// The web clears a compaction on completion/failure, so there is no web copy /// for a terminal record: those keep the label the server recorded. const _chatActivityRunningWords = { - 'compaction': 'Compacting context…', + 'compaction': chatCompactionPhaseLabel, 'thinking': 'Thinking…', 'tool': 'Running a tool…', 'waiting': 'Waiting…', diff --git a/app/test/features/chat/conversation/chat_notice_test.dart b/app/test/features/chat/conversation/chat_notice_test.dart new file mode 100644 index 00000000..70104b47 --- /dev/null +++ b/app/test/features/chat/conversation/chat_notice_test.dart @@ -0,0 +1,404 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_thread_view.dart'; +import 'package:pipelines_app/features/chat/domain/chat_notice.dart'; +import 'package:pipelines_app/features/chat/domain/chat_transcript.dart'; + +import 'chat_thread_fixtures.dart'; + +Widget host(Widget child) => MaterialApp( + theme: ThemeData(platform: TargetPlatform.android), + home: Scaffold(body: child), +); + +Widget cupertinoHost(Widget child) => CupertinoApp( + theme: const CupertinoThemeData(brightness: Brightness.dark), + home: CupertinoPageScaffold(child: child), +); + +JsonMap compactionTurn( + String messageId, + String id, [ + String state = 'running', +]) => chatMessage( + messageId, + 'assistant', + parts: [ + {'type': 'compaction', 'kind': 'compaction', 'id': id, 'status': state}, + ], +); + +JsonMap runningCompaction(String id) => compactionTurn('a1', id); + +const compactionDismissKey = ValueKey('chat-notice-dismiss-compaction'); + +void main() { + test('each recorded condition keeps its own exact wording', () { + final notices = chatNotices( + historyError: 'Bad state: Connection closed', + liveError: 'Exception: live watch refused', + messages: [runningCompaction('c1')], + ); + + expect(notices, hasLength(3)); + expect(notices[0].kind, ChatNoticeKind.connectionRefused); + expect(notices[0].text, 'Chat history unavailable\nConnection closed'); + expect(notices[1].kind, ChatNoticeKind.liveFailure); + expect(notices[1].text, 'Live updates unavailable\nlive watch refused'); + // The phase words are the web's own (`turnPhaseLabel`). + expect(notices[2].kind, ChatNoticeKind.compaction); + expect(notices[2].text, 'Compacting context…'); + expect(notices[2].detail, isEmpty); + expect( + [for (final kind in ChatNoticeKind.values) chatNoticeDismissLabel(kind)], + [ + 'Dismiss connection notice', + 'Dismiss live updates notice', + 'Dismiss compaction notice', + ], + ); + // A later compaction has its own recorded condition. + final next = chatNotices(messages: [runningCompaction('c2')]).single; + expect(next.condition, isNot(notices[2].condition)); + }); + + test('a dismissal hides one condition until that condition changes', () { + final dismissals = ChatNoticeDismissals(); + final first = chatNotices(liveError: 'first refusal').single; + expect(dismissals.visible([first]), [first]); + + dismissals.dismiss(first); + expect(dismissals.visible([first]), isEmpty); + // The same recorded condition stays hidden. + expect( + dismissals.visible(chatNotices(liveError: 'first refusal')), + isEmpty, + ); + + // A different recorded reason is a new notice. + final second = dismissals + .visible(chatNotices(liveError: 'second refusal')) + .single; + expect(second.text, 'Live updates unavailable\nsecond refusal'); + + // A condition that disappears and comes back is recorded afresh. + expect(dismissals.visible(const []), isEmpty); + expect( + dismissals.visible(chatNotices(liveError: 'first refusal')).single.text, + 'Live updates unavailable\nfirst refusal', + ); + }); + + test('a reconnect forgets every earlier dismissal', () { + final dismissals = ChatNoticeDismissals(); + final notice = chatNotices(historyError: 'Connection closed').single; + dismissals.dismiss(notice); + expect(dismissals.visible([notice]), isEmpty); + + dismissals.clear(); + expect(dismissals.visible([notice]), [notice]); + }); + + test('an unchanged transcript invents no notice', () { + expect(chatNotices(), isEmpty); + expect(chatNotices(messages: const []), isEmpty); + expect( + chatNotices( + messages: [ + chatMessage( + 'a1', + 'assistant', + parts: [ + {'type': 'text', 'text': 'Just an answer.'}, + {'type': 'reasoning', 'text': 'Thinking.'}, + { + 'type': 'tool', + 'state': {'status': 'completed'}, + }, + ], + ), + ], + ), + isEmpty, + ); + // A compaction that already ended is recorded history, not a live notice. + expect( + chatNotices( + messages: [ + chatMessage( + 'a1', + 'assistant', + parts: [ + { + 'type': 'compaction', + 'kind': 'compaction', + 'id': 'c1', + 'status': 'completed', + }, + ], + ), + ], + ), + isEmpty, + ); + }); + + test('a later terminal record supersedes an earlier running compaction', () { + final messages = [ + compactionTurn('a1', 'c1'), + compactionTurn('a2', 'c2', 'completed'), + ]; + + expect(chatRunningCompaction(messages), isNull); + expect(chatNotices(messages: messages), isEmpty); + // The line itself is still the recorded activity: the compaction ended. + expect(transcriptRows(messages).single['state'], 'completed'); + expect( + chatNoticeActivityCondition(transcriptRows(messages).single), + isNull, + ); + }); + + test('each running compaction row carries its own notice condition', () { + final rows = transcriptRows([ + compactionTurn('a1', 'c1'), + chatMessage('u1', 'user', parts: const []), + compactionTurn('a2', 'c2'), + ]); + final conditions = [ + for (final row in rows) + if (row['kind'] == 'activity') chatNoticeActivityCondition(row), + ]; + + expect(conditions, ['compaction\nc1', 'compaction\nc2']); + // The transcript's newest running compaction is the one it reports. + expect( + chatNotices( + messages: [ + compactionTurn('a1', 'c1'), + chatMessage('u1', 'user', parts: const []), + compactionTurn('a2', 'c2'), + ], + ).single.condition, + 'compaction\nc2', + ); + }); + + testWidgets('the live failure notice has a native dismiss that hides it', ( + tester, + ) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.subscribe = () async => throw StateError('live watch refused'); + gateway.history = (_) async => chatPage(const []); + + await tester.pumpWidget( + host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), + ); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('chat-live-error')), findsOneWidget); + expect(find.textContaining('live watch refused'), findsOneWidget); + + await tester.tap( + find.byKey(const ValueKey('chat-notice-dismiss-liveFailure')), + ); + await tester.pump(); + + expect(find.byKey(const Key('chat-live-error')), findsNothing); + expect(find.textContaining('live watch refused'), findsNothing); + + // A later transcript frame changes no condition, so it stays hidden. + gateway.emitEvent(chatTextFrame('An answer.')); + await tester.pumpAndSettle(); + expect(find.byKey(const Key('chat-live-error')), findsNothing); + }); + + testWidgets('a reconnect clears the stale notice and its dismissal', ( + tester, + ) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.subscribe = () async => throw StateError('live watch refused'); + gateway.history = (_) async => chatPage(const []); + + await tester.pumpWidget( + host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), + ); + await tester.pumpAndSettle(); + await tester.tap( + find.byKey(const ValueKey('chat-notice-dismiss-liveFailure')), + ); + await tester.pump(); + expect(find.byKey(const Key('chat-live-error')), findsNothing); + + // The socket comes back and the watch is accepted: the recorded condition + // is gone, so the old notice cannot linger. + gateway.subscribe = () async => const {}; + await tester.pumpWidget( + host( + ChatThreadView( + gateway: gateway, + sessionId: 's', + onBack: () {}, + syncToken: 1, + ), + ), + ); + // The pre-gap notice is stale as soon as the socket is replaced. + await tester.pump(); + expect(find.byKey(const Key('chat-live-error')), findsNothing); + await tester.pumpAndSettle(); + expect(find.byKey(const Key('chat-live-error')), findsNothing); + + // A failure recorded after the reconnect is shown again: the old dismissal + // did not survive the gap, even though the words repeat. + gateway.subscribe = () async => throw StateError('live watch refused'); + await tester.pumpWidget( + host( + ChatThreadView( + gateway: gateway, + sessionId: 's', + onBack: () {}, + syncToken: 2, + ), + ), + ); + await tester.pumpAndSettle(); + expect(find.byKey(const Key('chat-live-error')), findsOneWidget); + expect(find.textContaining('live watch refused'), findsOneWidget); + }); + + testWidgets('a reconnect hides a stale running compaction until fresh state', ( + tester, + ) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => chatPage([runningCompaction('c1')]); + + await tester.pumpWidget( + host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), + ); + await tester.pumpAndSettle(); + expect(find.text('Compacting context…'), findsOneWidget); + await tester.tap(find.byKey(compactionDismissKey)); + await tester.pump(); + expect(find.text('Compacting context…'), findsNothing); + + // The socket is replaced and the repair's history read has not answered: + // the pre-gap running state is stale, and the earlier dismissal does not + // make it visible again. + gateway.history = null; + await tester.pumpWidget( + host( + ChatThreadView( + gateway: gateway, + sessionId: 's', + onBack: () {}, + syncToken: 1, + ), + ), + ); + await tester.pump(); + expect(find.text('Compacting context…'), findsNothing); + expect(find.byKey(compactionDismissKey), findsNothing); + + // The repair reports the same compaction still running: the fresh record + // shows again with its dismiss control; the gap cleared the old dismissal. + gateway.historyRequests.last.complete(chatPage([runningCompaction('c1')])); + await tester.pumpAndSettle(); + expect(find.text('Compacting context…'), findsOneWidget); + expect(find.byKey(compactionDismissKey), findsOneWidget); + }); + + testWidgets('a refused repair keeps the pre-gap compaction hidden', ( + tester, + ) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => chatPage([runningCompaction('c1')]); + + await tester.pumpWidget( + host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), + ); + await tester.pumpAndSettle(); + await tester.tap(find.byKey(compactionDismissKey)); + await tester.pump(); + expect(find.text('Compacting context…'), findsNothing); + + gateway.history = (_) async => throw StateError('history refused'); + await tester.pumpWidget( + host( + ChatThreadView( + gateway: gateway, + sessionId: 's', + onBack: () {}, + syncToken: 1, + ), + ), + ); + await tester.pumpAndSettle(); + + // The refused repair is a fresh failure notice; the held transcript's + // running compaction is not painted again as if it were current. + expect(find.byKey(const Key('chat-history-error')), findsOneWidget); + expect(find.textContaining('history refused'), findsOneWidget); + expect(find.text('Compacting context…'), findsNothing); + expect(find.byKey(compactionDismissKey), findsNothing); + }); + + testWidgets('dismissing one running compaction leaves the other line alone', ( + tester, + ) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => chatPage([ + compactionTurn('a1', 'c1'), + chatMessage('u1', 'user', parts: const []), + compactionTurn('a2', 'c2'), + ]); + + await tester.pumpWidget( + host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), + ); + await tester.pumpAndSettle(); + expect(find.text('Compacting context…'), findsNWidgets(2)); + // Only the transcript's newest running compaction is the reported notice. + expect(find.byKey(compactionDismissKey), findsOneWidget); + + await tester.tap(find.byKey(compactionDismissKey)); + await tester.pump(); + + // c2's line is hidden; the separately recorded c1 line keeps its words. + expect(find.text('Compacting context…'), findsOneWidget); + expect(find.byKey(compactionDismissKey), findsNothing); + }); + + testWidgets('a running compaction notice is native, dismissed and exact', ( + tester, + ) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => chatPage([runningCompaction('c1')]); + + await tester.pumpWidget( + cupertinoHost( + ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}), + ), + ); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('chat-compaction-notice')), findsNothing); + expect(find.text('Compacting context…'), findsOneWidget); + expect(find.byType(Material), findsNothing); + expect(find.bySemanticsLabel('Dismiss compaction notice'), findsOneWidget); + + await tester.tap( + find.byKey(const ValueKey('chat-notice-dismiss-compaction')), + ); + await tester.pump(); + expect(find.text('Compacting context…'), findsNothing); + }); +}