diff --git a/AGENTS.md b/AGENTS.md index faba7571..1cdd0fbc 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -69,7 +69,7 @@ Não violar estes pontos sob qualquer hipótese: - Ambos usam o cliente gerado `sinalacs_client` por dependência local e não devem depender diretamente de detalhes de implementação do servidor em widgets. - O app ACS é o mais crítico em termos de offline-first e sincronização: guarda visitas locais, tenta sincronizar em fila e trata conflitos sem perder registros. - O tema visual é dark mode, com foco em legibilidade e uso de cor restrito a sinal clínico (vermelho, amarelo, verde). -- O app do paciente não deve reintroduzir regras de risco no cliente; a classificação deve vir do backend via `triage.evaluate`. +- O app do paciente não deve reintroduzir regras de risco no cliente, com **uma** exceção (C-11, #132): no pilar A, sem login, a autoavaliação roda no aparelho por `SelfAssessmentEngine` (`apps/patient/lib/core/triage/self_assessment.dart`), cópia da árvore do `TriageEngine`. A INV-02 passa a depender das duas serem iguais, e `backend/sinalacs_server/test/unit/self_assessment_parity_test.dart` as compara nas 64 combinações em todo PR (job `serverpod-backend`). Mudou um motor, mude o outro no mesmo PR e suba `selfAssessmentEngineVersion`. Com sessão (pilar B), a classificação continua vindo do backend via `triage.evaluate`. - [apps/admin](apps/admin) (`sinalacs_admin`) é o backoffice administrativo — deixou de ser um esqueleto de pubspec e hoje é um app navegável real, com 4 telas somente leitura (Indicadores, Microáreas, Alertas, Auditoria) atrás de `AdminHomeShell`. Ainda não consome `sinalacs_client`: usa a interface `AdminDataSource`, hoje implementada só por `MockAdminDataSource`, seguindo o mesmo padrão de DI de `PatientBackend`/`AcsBackend`. O login é local e não chama `auth.developmentLogin` (o backend só aceita `role: 'patient'`/`role: 'acs'` hoje). Toda tela que exibe dado sensível registra o próprio acesso via `recordAccess()` antes de renderizar, por exigência de auditoria do PRD §4.2.2. É o único dos três apps com suporte a Flutter Web, e desde a adição da plataforma Android também roda em celular e tablet (`flutter run -d emulator-5554`). O layout segue desktop-first: os pontos de quebra ficam em `lib/app/admin_layout.dart` e o layout compacto é complemento, nunca substituição — os dez testes de widget originais continuam passando sem edição, o que é o que prova isso. ### Infraestrutura local diff --git a/PROGRESS.md b/PROGRESS.md index aa594cc0..31a4dbd5 100644 --- a/PROGRESS.md +++ b/PROGRESS.md @@ -1941,6 +1941,15 @@ Branch `feat/issue-127-pedido-de-contato-192`. Pré-requisito do portão do pilo - **Lado do agente e backend:** o ACS e o backoffice continuam chamando o pedido de alerta vermelho ("Risco: Vermelho"). A issue não pediu mudança lá; fica para decisão do dono. - **Captura de tela** `docs/screenshots/patient/01-emergencia.png` é anterior à C-04. +## Autoavaliação local no pilar A (C-11, #132) — 2026-11-10 + +Branch `feat/issue-132-autoavaliacao-local`, **empilhada sobre a #127** (o vermelho local precisa da orientação "Ligar 192"; sem ela apareceria a promessa antiga "Sua equipe de saúde foi avisada"). + +- **O que mudou.** A tela de entrada ganhou **Autoavaliação (sem cadastro)** (`LocalSelfAssessmentScreen`), que roda a árvore no aparelho por `SelfAssessmentEngine` (`apps/patient/lib/core/triage/self_assessment.dart`, Dart puro sem import): sem `accessToken`, sem rede, sem `triage_sessions`, sem gravar as respostas. O resultado local diz que nada foi enviado e troca "Acompanhar solicitação" por "Concluir"; o vermelho abre a orientação "Ligar 192" e grava o evento local (C-04). Com sessão (pilar B), nada muda: `triage.evaluate`. Backend sem mudança. +- **Paridade (INV-02 com dois motores).** `backend/sinalacs_server/test/unit/self_assessment_parity_test.dart` importa o motor do app por caminho relativo e o compara com o `TriageEngine` nas 64 combinações, por nome do nível, e exige que as três saídas apareçam. Roda no `dart test` do job `serverpod-backend` (check obrigatório) em **todo** PR — o workflow não tem filtro de caminho, garantido por `ci_invariants.sh` —, seja qual for o motor alterado. Mutação conferida: tirar `bleeding` do vermelho do app reprova na combinação 16. Mover o arquivo do app quebra a compilação do teste, em vez de desligá-lo em silêncio. +- **Provas.** Paciente: `flutter analyze` sem avisos, 355 testes. `test/local_self_assessment_test.dart` (5) usa um backend que registra **qualquer** método chamado: nenhum na autoavaliação local; forçar o modo remoto na tela reprova 4 dos 5. Backend: `dart analyze` sem issue nova; o teste de paridade e o `triage_engine_test.dart` verdes. +- **Limites.** A regra de "mudou um motor, mude o outro e suba `selfAssessmentEngineVersion`" está documentada (`AGENTS.md`, `apps/CLAUDE.md`) e a paridade é testada, mas a versão não é: o backend não tem versão do motor. Os textos das três saídas seguem os antigos ("Risco: …") até a C-08 (#130). Não verificado no aparelho. + ## Aviso educativo na primeira abertura e em "Sobre" (C-02, #125) — 2026-11-08 Branch `feat/c-02-aviso-educativo`. RF21 nos apps do paciente e do agente. diff --git a/apps/CLAUDE.md b/apps/CLAUDE.md index 4b33c38f..d003463c 100644 --- a/apps/CLAUDE.md +++ b/apps/CLAUDE.md @@ -54,7 +54,7 @@ The onboarding QR (RF02) now exists on both sides: the ACS's "Mais › Convidar The UI depends on the interface, never on the generated `Client`, which is what keeps the widget tests hermetic; the live path is checked by `tool/live_check.dart` in each app and by `integration_test/`. -Risk classification now comes **only** from `triage.evaluate`: the patient app's client-side string-matching rule is gone, and its triage form asks the six symptoms the server's engine actually takes. The ACS dashboard is fed by `AlertQueue`, which receives alerts over MQTT and orders them deterministically by risk and then by age; it rejects alerts from another micro-area and de-duplicates re-deliveries (QoS 1 is at-least-once). +Risk classification in the patient app comes from `triage.evaluate` when there is a session (pilar B): the old client-side string-matching rule is gone, and the triage form asks the six symptoms the server's engine actually takes. **Only exception, C-11 (#132):** without login (pilar A) the self-assessment runs on the device — `LocalSelfAssessmentScreen` (login screen button `login_self_assessment_button`) mounts `TriageScreen(local: true)`, which calls `SelfAssessmentEngine` (`lib/core/triage/self_assessment.dart`, pure Dart with **no imports**, translated to `RiskLevel` by name), never reads `BackendScope`, sends nothing and writes nothing to `triage_sessions`; its result says nothing was sent ("Concluir" instead of "Acompanhar solicitação"), and red still opens the "Ligar 192" orientation (C-04). Two implementations of one closed tree: `backend/sinalacs_server/test/unit/self_assessment_parity_test.dart` imports the app file by relative path and compares it with `TriageEngine` over the 64 combinations, in the `serverpod-backend` job of every PR — change both engines in the same PR and bump `selfAssessmentEngineVersion`. `test/local_self_assessment_test.dart` proves the no-network path with a backend that records any call. The ACS dashboard is fed by `AlertQueue`, which receives alerts over MQTT and orders them deterministically by risk and then by age; it rejects alerts from another micro-area and de-duplicates re-deliveries (QoS 1 is at-least-once). Color is a clinical signal only in these apps: red/yellow/green map strictly to `RiskLevel`, never used decoratively. diff --git a/apps/patient/lib/app/app.dart b/apps/patient/lib/app/app.dart index b70999b1..da251c0d 100644 --- a/apps/patient/lib/app/app.dart +++ b/apps/patient/lib/app/app.dart @@ -47,6 +47,7 @@ import 'package:sinalacs_patient/core/storage/local_data_control.dart'; import 'package:sinalacs_patient/core/storage/local_database_key.dart' show LocalDatabaseUnavailableException; import 'package:sinalacs_patient/core/services/emergency_dialer.dart'; +import 'package:sinalacs_patient/core/triage/self_assessment.dart'; import 'package:sinalacs_patient/core/services/theme_controller.dart'; class SinalAcsApp extends StatefulWidget { @@ -687,6 +688,21 @@ class _PatientLoginScreenState extends State { label: const Text('Biblioteca de saúde (sem cadastro)'), ), ), + const SizedBox(height: 12), + // Pilar A (C-11, RF22): a autoavaliação roda no + // aparelho, sem conta e sem rede. + SizedBox( + width: double.infinity, + child: OutlinedButton.icon( + key: const Key('login_self_assessment_button'), + style: OutlinedButton.styleFrom(minimumSize: const Size(48, 52)), + onPressed: () => Navigator.of(context).push( + MaterialPageRoute(builder: (_) => const LocalSelfAssessmentScreen()), + ), + icon: const Icon(Icons.assignment_outlined), + label: const Text('Autoavaliação (sem cadastro)'), + ), + ), const SizedBox(height: 4), TextButton( key: const Key('login_legal_link'), @@ -1550,9 +1566,15 @@ class _EmergencyScreenState extends State { } class TriageScreen extends StatefulWidget { - const TriageScreen({super.key, this.onComplete, this.onFailure}); + const TriageScreen({super.key, this.onComplete, this.onFailure, this.local = false}); final VoidCallback? onComplete; + /// Pilar A (C-11, #132): `true` roda a árvore no aparelho + /// ([SelfAssessmentEngine]), sem `accessToken`, sem rede e sem gravar em + /// `triage_sessions`. `false` (pilar B, com sessão) chama `triage.evaluate`. + /// No modo local a tela nunca lê o `BackendScope`. + final bool local; + /// Relata ao shell a falha capturada nesta tela. Ver /// `_PatientHomeShellState._reportFailure`. final ValueChanged? onFailure; @@ -1612,7 +1634,7 @@ class _TriageScreenState extends State { }); try { - final risk = await BackendScope.of(context).evaluateTriage( + final risk = widget.local ? _evaluateOnDevice() : await BackendScope.of(context).evaluateTriage( chestPain: _answers[TriageSymptom.chestPain] ?? false, difficultyBreathing: _answers[TriageSymptom.difficultyBreathing] ?? false, fever: _answers[TriageSymptom.fever] ?? false, @@ -1639,6 +1661,22 @@ class _TriageScreenState extends State { } } + /// Mesma árvore do `TriageEngine` do backend, no aparelho (C-11). A paridade + /// nas 64 combinações é provada por + /// `backend/sinalacs_server/test/unit/self_assessment_parity_test.dart`. + /// A tradução para [RiskLevel] é por **nome**, nunca por índice. + RiskLevel _evaluateOnDevice() { + final level = const SelfAssessmentEngine().evaluate( + chestPain: _answers[TriageSymptom.chestPain] ?? false, + difficultyBreathing: _answers[TriageSymptom.difficultyBreathing] ?? false, + fever: _answers[TriageSymptom.fever] ?? false, + persistentVomiting: _answers[TriageSymptom.persistentVomiting] ?? false, + bleeding: _answers[TriageSymptom.bleeding] ?? false, + severeWeakness: _answers[TriageSymptom.severeWeakness] ?? false, + ); + return RiskLevel.values.byName(level.name); + } + /// Saída de maior gravidade: só a orientação "Ligar 192" (P-09, C-04). /// /// **Nenhum pedido de contato sai daqui** — nada de `createRedAlert`; o @@ -1660,7 +1698,9 @@ class _TriageScreenState extends State { @override Widget build(BuildContext context) { final risk = _risk; - if (risk != null) return _TriageResult(risk: risk, onContinue: widget.onComplete); + if (risk != null) { + return _TriageResult(risk: risk, onContinue: widget.onComplete, local: widget.local); + } final symptom = _symptoms[_step]; final answer = _answers[symptom]; @@ -1731,11 +1771,16 @@ class _TriageScreenState extends State { /// A cor é sinal clínico, nunca decoração: vermelho/amarelo/verde mapeiam /// estritamente o [RiskLevel]. class _TriageResult extends StatelessWidget { - const _TriageResult({required this.risk, this.onContinue}); + const _TriageResult({required this.risk, this.onContinue, this.local = false}); final RiskLevel risk; final VoidCallback? onContinue; + /// Resultado da autoavaliação local (C-11): nada foi enviado, então a tela + /// não pode falar de "solicitação" nem de agente que entrará em contato. + /// Os textos finais das três saídas são da C-08 (#130). + final bool local; + @override Widget build(BuildContext context) { // `color` só é usada como texto/ícone sobre o card (nenhum botão herda @@ -1780,7 +1825,13 @@ class _TriageResult extends StatelessWidget { style: TextStyle(fontSize: 22, fontWeight: FontWeight.bold, color: color), ), const SizedBox(height: 12), - Text(guidance, textAlign: TextAlign.center), + Text( + local + ? 'Esta autoavaliação ficou só neste aparelho: nada foi enviado ao agente nem ao servidor.' + : guidance, + key: const Key('triage_guidance'), + textAlign: TextAlign.center, + ), const SizedBox(height: 8), Text( 'Classificação feita pelo protocolo da equipe de saúde.', @@ -1796,13 +1847,33 @@ class _TriageResult extends StatelessWidget { key: const Key('triage_continue'), onPressed: onContinue, style: FilledButton.styleFrom(minimumSize: const Size(48, 52)), - child: const Text('Acompanhar solicitação'), + child: Text(local ? 'Concluir' : 'Acompanhar solicitação'), ), ], ); } } +/// Autoavaliação do pilar A, aberta pela tela de entrada sem conta (C-11, #132; +/// RF04, RF22, RNF09): roda no aparelho, sem sessão, sem rede e sem registro no +/// servidor. A saída de maior gravidade é a orientação "Ligar 192" (C-04). +class LocalSelfAssessmentScreen extends StatelessWidget { + const LocalSelfAssessmentScreen({super.key}); + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: AppBar(title: const Text('Autoavaliação')), + body: SafeArea( + child: TriageScreen( + local: true, + onComplete: () => Navigator.of(context).pop(), + ), + ), + ); + } +} + /// Catálogo de condições que a tela oferece para marcar/desmarcar — mesmo /// conjunto que `spec/idea.md` documenta como a origem do produto ("Perfil /// Clínico e Cadastro de Crônicos"): diabetes, hipertensão, uso contínuo de diff --git a/apps/patient/lib/core/triage/self_assessment.dart b/apps/patient/lib/core/triage/self_assessment.dart index 73de2435..76fca2b3 100644 --- a/apps/patient/lib/core/triage/self_assessment.dart +++ b/apps/patient/lib/core/triage/self_assessment.dart @@ -1,8 +1,59 @@ +/// Motor de autoavaliação no aparelho (C-11, #132; RF04, RF16, INV-02). +/// +/// No pilar A (sem login) a autoavaliação roda **aqui**, sem rede, sem +/// `accessToken` e sem gravar em `triage_sessions`. No pilar B (com sessão) o +/// app continua chamando `triage.evaluate`, que roda o `TriageEngine` do +/// backend e grava a sessão. +/// +/// São, portanto, **duas implementações da mesma árvore de decisão fechada**, e +/// a INV-02 passa a depender de elas serem iguais. Quem prova isso é +/// `backend/sinalacs_server/test/unit/self_assessment_parity_test.dart`, que +/// importa ESTE arquivo e compara as duas nas 64 combinações dos seis sinais. +/// Ele roda no job `serverpod-backend` do CI em todo PR, seja qual for o motor +/// alterado. +/// +/// **Este arquivo não pode importar nada** — nem Flutter, nem +/// `sinalacs_client`: o teste de paridade o carrega na VM do backend, que não +/// tem esses pacotes. +library; + /// Versão da árvore de decisão da autoavaliação (RF16, INV-02). /// /// Vai no evento local da saída "Ligar 192" (C-04, `spec/requisitos_piloto.md` /// §INV-03 no piloto: "evento com data, hora e versão do motor"). Quem mudar -/// as regras da árvore — no backend (`TriageEngine`) ou no aparelho — sobe -/// esta versão no mesmo commit, para que um evento antigo continue dizendo -/// qual regra o produziu. +/// as regras da árvore — no backend (`TriageEngine`) ou aqui — sobe esta +/// versão no mesmo commit, para que um evento antigo continue dizendo qual +/// regra o produziu. const selfAssessmentEngineVersion = 'arvore-v1'; + +/// Saída do motor. Os nomes são os mesmos do `RiskLevel` do backend e do +/// cliente gerado; a tela traduz por **nome**, nunca por índice. +enum SelfAssessmentLevel { red, yellow, green } + +/// Mesma árvore do `TriageEngine` do backend +/// (`backend/sinalacs_server/lib/src/application/triage/triage_engine.dart`). +/// +/// Determinística: mesma entrada, mesma saída, sem estado, relógio, sorteio ou +/// campo editável (INV-02). +class SelfAssessmentEngine { + const SelfAssessmentEngine(); + + SelfAssessmentLevel evaluate({ + required bool chestPain, + required bool difficultyBreathing, + required bool fever, + required bool persistentVomiting, + required bool bleeding, + required bool severeWeakness, + }) { + if (chestPain || difficultyBreathing || severeWeakness || bleeding) { + return SelfAssessmentLevel.red; + } + + if (fever || persistentVomiting) { + return SelfAssessmentLevel.yellow; + } + + return SelfAssessmentLevel.green; + } +} diff --git a/apps/patient/test/local_self_assessment_test.dart b/apps/patient/test/local_self_assessment_test.dart new file mode 100644 index 00000000..fec02d88 --- /dev/null +++ b/apps/patient/test/local_self_assessment_test.dart @@ -0,0 +1,149 @@ +/// C-11 (#132): autoavaliação local no pilar A, sem sessão nem registro no +/// servidor (RF04, RF16, RF22, RNF09). +/// +/// A paridade das 64 combinações com o motor do backend é provada do lado do +/// servidor, por `backend/sinalacs_server/test/unit/self_assessment_parity_test.dart`, +/// que importa o motor do app; aqui se prova que a tela usa esse motor e que +/// nada sai do aparelho. +library; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:sinalacs_client/sinalacs_client.dart' show RiskLevel; +import 'package:sinalacs_patient/app/app.dart'; +import 'package:sinalacs_patient/core/events/local_event_log.dart'; +import 'package:sinalacs_patient/core/network/backend_client.dart'; +import 'package:sinalacs_patient/core/triage/self_assessment.dart'; + +import 'support/fake_patient_backend.dart'; + +/// Backend que registra TODA chamada, de qualquer método, e falha. É a rede do +/// app: o paciente não fala com o servidor por nenhum outro caminho. +class _NetworkSentinel implements PatientBackend { + final calls = []; + + @override + dynamic noSuchMethod(Invocation invocation) { + calls.add(invocation.memberName); + throw StateError('chamada de rede na autoavaliação local: ${invocation.memberName}'); + } +} + +Future _openLocalSelfAssessment(WidgetTester tester) async { + final entrada = find.byKey(const Key('login_self_assessment_button')); + await tester.ensureVisible(entrada); + await tester.pumpAndSettle(); + await tester.tap(entrada); + await tester.pumpAndSettle(); +} + +Future _answer(WidgetTester tester, Set yesTo) async { + for (final symptom in TriageSymptom.values) { + final key = yesTo.contains(symptom) ? symptom.key : '${symptom.key}_no'; + await tester.tap(find.byKey(Key(key))); + await tester.pump(); + await tester.tap(find.byKey(const Key('submit_triage'))); + await tester.pumpAndSettle(); + } +} + +void main() { + testWidgets('sem login: a autoavaliação abre na entrada e não faz nenhuma chamada de rede', (tester) async { + final backend = _NetworkSentinel(); + await tester.pumpWidget(SinalAcsApp(backend: backend, localEvents: InMemoryLocalEventLog())); + await tester.pumpAndSettle(); + final antes = List.of(backend.calls); + + await _openLocalSelfAssessment(tester); + await _answer(tester, {TriageSymptom.fever}); + + expect(find.text('Risco: Amarelo'), findsOneWidget); + expect(backend.calls, antes, reason: 'nenhum método do backend pode ser chamado no pilar A'); + }); + + testWidgets('o resultado local não fala de solicitação nem de agente', (tester) async { + await tester.pumpWidget(SinalAcsApp(backend: _NetworkSentinel())); + await tester.pumpAndSettle(); + await _openLocalSelfAssessment(tester); + + await _answer(tester, const {}); + + expect(find.text('Risco: Verde'), findsOneWidget); + expect(find.textContaining('nada foi enviado'), findsOneWidget); + expect(find.textContaining('solicitação'), findsNothing); + expect(find.textContaining('entrará em contato'), findsNothing); + + // "Concluir" volta à entrada, ainda sem conta. + await tester.tap(find.byKey(const Key('triage_continue'))); + await tester.pumpAndSettle(); + expect(find.byKey(const Key('cpf_field')), findsOneWidget); + }); + + testWidgets('vermelho local: orientação "Ligar 192", evento local e nada enviado', (tester) async { + final backend = _NetworkSentinel(); + final events = InMemoryLocalEventLog(); + await tester.pumpWidget(SinalAcsApp(backend: backend, localEvents: events)); + await tester.pumpAndSettle(); + final antes = List.of(backend.calls); + await _openLocalSelfAssessment(tester); + + await _answer(tester, {TriageSymptom.bleeding}); + + expect(find.byKey(const Key('call_192_title')), findsOneWidget); + expect(backend.calls, antes); + final gravados = await events.list(); + expect(gravados.single.kind, LocalEventKind.call192OrientationShown); + expect(gravados.single.engineVersion, selfAssessmentEngineVersion); + + await tester.tap(find.byKey(const Key('call_192_close'))); + await tester.pumpAndSettle(); + expect(find.text('Passo 1 de 6'), findsOneWidget); + }); + + testWidgets('a tela segue o motor do aparelho: cada saída da árvore aparece', (tester) async { + // Uma amostra que cobre as três saídas pelo widget; as 64 combinações são + // comparadas com o backend no teste de paridade. + const engine = SelfAssessmentEngine(); + final casos = , String>{ + {TriageSymptom.persistentVomiting}: 'Risco: Amarelo', + {TriageSymptom.fever, TriageSymptom.persistentVomiting}: 'Risco: Amarelo', + const {}: 'Risco: Verde', + }; + for (final MapEntry(key: sim, value: rotulo) in casos.entries) { + final esperado = engine.evaluate( + chestPain: sim.contains(TriageSymptom.chestPain), + difficultyBreathing: sim.contains(TriageSymptom.difficultyBreathing), + fever: sim.contains(TriageSymptom.fever), + persistentVomiting: sim.contains(TriageSymptom.persistentVomiting), + bleeding: sim.contains(TriageSymptom.bleeding), + severeWeakness: sim.contains(TriageSymptom.severeWeakness), + ); + expect(rotulo, 'Risco: ${{'yellow': 'Amarelo', 'green': 'Verde'}[esperado.name]}'); + + await tester.pumpWidget(SinalAcsApp(backend: _NetworkSentinel())); + await tester.pumpAndSettle(); + await _openLocalSelfAssessment(tester); + await _answer(tester, sim); + expect(find.text(rotulo), findsOneWidget, reason: '$sim'); + await tester.pumpWidget(const SizedBox()); + } + }); + + testWidgets('com sessão (pilar B), a autoavaliação continua indo ao servidor', (tester) async { + final backend = FakePatientBackend(risk: RiskLevel.yellow); + await tester.pumpWidget(SinalAcsApp(backend: backend)); + await tester.enterText(find.byKey(const Key('cpf_field')), '123.456.789-09'); + await tester.enterText(find.byKey(const Key('birth_date_field')), '01/01/1990'); + await tester.tap(find.byKey(const Key('enter_button'))); + await tester.pumpAndSettle(); + await tester.enterText(find.byKey(const Key('otp_code_field')), '123456'); + await tester.tap(find.byKey(const Key('verify_code_button'))); + await tester.pumpAndSettle(); + + await _answer(tester, {TriageSymptom.fever}); + + expect(backend.triageCalls, hasLength(1)); + expect(find.text('Risco: Amarelo'), findsOneWidget); + expect(find.text('Acompanhar solicitação'), findsOneWidget); + }); +} diff --git a/backend/sinalacs_server/test/unit/self_assessment_parity_test.dart b/backend/sinalacs_server/test/unit/self_assessment_parity_test.dart new file mode 100644 index 00000000..4341e814 --- /dev/null +++ b/backend/sinalacs_server/test/unit/self_assessment_parity_test.dart @@ -0,0 +1,69 @@ +// Paridade entre os dois motores da autoavaliação (C-11, #132; INV-02). +// +// O app do paciente roda a árvore no aparelho no pilar A (sem login, sem rede); +// o backend roda o `TriageEngine` no pilar B (`triage.evaluate`). As duas +// implementações têm de dar o mesmo resultado para as 64 combinações dos seis +// sinais. Este teste importa o motor do app por caminho relativo — por isso o +// arquivo do app é Dart puro, sem nenhum import — e roda em todo PR no job +// `serverpod-backend` do CI, seja qual for o motor que mudou. +// +// Se o arquivo do app mudar de lugar, este import quebra a compilação do teste +// (e o job fica vermelho): a paridade nunca deixa de ser verificada em silêncio. +import 'package:sinalacs_server/src/application/triage/triage_engine.dart'; +import 'package:sinalacs_server/src/generated/protocol.dart'; +import 'package:test/test.dart'; + +// O `lib/` é o do app do paciente, outro pacote: não há `package:` que o +// alcance daqui sem trazer o Flutter para o backend. O caminho relativo é o +// ponto do teste. +// ignore: avoid_relative_lib_imports +import '../../../../apps/patient/lib/core/triage/self_assessment.dart' as app; + +void main() { + test('o motor do aparelho e o do backend dão o mesmo resultado nas 64 combinações', () { + const server = TriageEngine(); + const device = app.SelfAssessmentEngine(); + final seen = {}; + + for (var mask = 0; mask < 64; mask++) { + final chestPain = mask & 1 != 0; + final difficultyBreathing = mask & 2 != 0; + final fever = mask & 4 != 0; + final persistentVomiting = mask & 8 != 0; + final bleeding = mask & 16 != 0; + final severeWeakness = mask & 32 != 0; + + final RiskLevel expected = server.evaluate( + chestPain: chestPain, + difficultyBreathing: difficultyBreathing, + fever: fever, + persistentVomiting: persistentVomiting, + bleeding: bleeding, + severeWeakness: severeWeakness, + ); + final actual = device.evaluate( + chestPain: chestPain, + difficultyBreathing: difficultyBreathing, + fever: fever, + persistentVomiting: persistentVomiting, + bleeding: bleeding, + severeWeakness: severeWeakness, + ); + + // Por nome, como o app traduz: um índice reordenado passaria despercebido. + expect(actual.name, expected.name, reason: 'combinação $mask'); + seen.add(expected.name); + } + + // As três saídas aparecem: uma árvore que devolvesse sempre o mesmo nível + // nos dois lados também seria "igual". + expect(seen, {'red', 'yellow', 'green'}); + }); + + test('os níveis do aparelho têm os mesmos nomes do RiskLevel do backend', () { + expect( + {for (final level in app.SelfAssessmentLevel.values) level.name}, + {for (final level in RiskLevel.values) level.name}, + ); + }); +} diff --git a/docs/telas-paciente.md b/docs/telas-paciente.md index 0b5bbd89..dcfe3ba5 100644 --- a/docs/telas-paciente.md +++ b/docs/telas-paciente.md @@ -24,7 +24,7 @@ Desde a C-04 (#127) a aba se chama **Contato**. No topo, antes de qualquer pedid ## Triagem rápida -Seis perguntas de sim ou não (dor no peito, falta de ar, sangramento, fraqueza intensa ou desmaio, febre, vômitos que não param), uma por etapa, com indicador de progresso. O risco é calculado pelo servidor (`triage.evaluate`), de forma determinística, e não pode ser editado pela pessoa usuária. Ao finalizar, encaminha para o acompanhamento da solicitação. Desde a C-04 (#127), a saída de maior gravidade não mostra cartão de risco: abre em tela cheia a orientação **"Ligue 192 (SAMU) agora"**, com o botão Ligar 192, que só fecha por "Fechar esta orientação" (o voltar do sistema não fecha). Ela **não envia nada ao agente** e grava um evento na trilha local cifrada do aparelho (tipo, instante e versão do motor, sem respostas); depois a autoavaliação recomeça do zero. As outras duas saídas ainda mostram o cartão de risco antigo, até a C-08 (#130). +Seis perguntas de sim ou não (dor no peito, falta de ar, sangramento, fraqueza intensa ou desmaio, febre, vômitos que não param), uma por etapa, com indicador de progresso. Com sessão, o risco é calculado pelo servidor (`triage.evaluate`), de forma determinística, e não pode ser editado pela pessoa usuária. Sem conta, o botão **Autoavaliação (sem cadastro)** da tela de entrada abre a mesma sequência rodando no aparelho (C-11, #132): mesma árvore, nenhuma chamada de rede, nada gravado; o resultado diz que nada foi enviado e o botão é "Concluir". Ao finalizar, encaminha para o acompanhamento da solicitação. Desde a C-04 (#127), a saída de maior gravidade não mostra cartão de risco: abre em tela cheia a orientação **"Ligue 192 (SAMU) agora"**, com o botão Ligar 192, que só fecha por "Fechar esta orientação" (o voltar do sistema não fecha). Ela **não envia nada ao agente** e grava um evento na trilha local cifrada do aparelho (tipo, instante e versão do motor, sem respostas); depois a autoavaliação recomeça do zero. As outras duas saídas ainda mostram o cartão de risco antigo, até a C-08 (#130). ## Perfil clínico diff --git a/spec/lgpd_design.md b/spec/lgpd_design.md index 21a70b44..4076c968 100644 --- a/spec/lgpd_design.md +++ b/spec/lgpd_design.md @@ -17,7 +17,7 @@ Esta seção vale para o escopo atual do projeto ([`escopo_projeto.md`](escopo_p - **Controlador, encarregado e base legal — decisão aprovada P-02:** controlador UFRR, por meio do projeto, com o líder do Grupo PRISM como pesquisador responsável; encarregado é o encarregado institucional da UFRR (nome e contato `[A DEFINIR]`); base legal art. 11, II, "c" da LGPD (estudo por órgão de pesquisa); o TCLE é exigência ética (Res. CNS 466/2012 e 510/2016), não base legal. Confirmação jurídica: `[A DEFINIR]`. - **Coleta mínima (RNF09):** o pilar A (conteúdo educativo, lembretes, autoavaliação) funciona sem cadastro e com dados só no aparelho. O pilar B usa identificador pseudônimo, sem CPF, sem SMS e sem e-mail no login; recuperação de acesso por novo convite QR do agente participante, vinculado ao mesmo identificador e invalidando a sessão anterior (decisão aprovada P-10). Os dados da visita (microárea, endereço ou ponto de referência) seguem a minimização dos RF09/RF10. - **Dado de saúde é sempre sensível** (art. 11), inclusive as respostas da autoavaliação e o registro de que a pessoa recebeu a orientação "Ligar 192". -- **Dados locais do pilar A** (eventos de auditoria do aparelho, lembretes, respostas da autoavaliação): ficam só no aparelho. Os lembretes e o consentimento local já ficam cifrados (#136, abaixo). A trilha local de eventos existe desde a C-04 (#127), no mesmo banco cifrado (tabela `local_events`): guarda só o tipo do evento, o instante e a versão do motor — hoje um único tipo, a orientação "Ligar 192" exibida —, nunca as respostas, e não sai do aparelho. As respostas da autoavaliação **devem** ficar cifradas — meta, não estado atual: hoje a autoavaliação é enviada ao servidor (C-11). Os dados locais do pilar A (lembretes, consentimento local e, desde a C-04, a trilha de eventos) ficam num único banco SQLCipher (AES-256), com chave aleatória guardada pelo Android Keystore, sem segredo do usuário (#136). O backup e a transferência entre aparelhos estão desligados; a notificação do lembrete não leva o texto do lembrete. Uma falha de leitura da chave ou de abertura do banco não apaga nada; só a chave comprovadamente ausente recomeça o banco vazio, e o app pede de novo a autorização de lembretes. **Limite do pilar A:** protege contra cópia dos arquivos (backup, ADB, extração do armazenamento, aparelho perdido desligado ou bloqueado), não contra quem usa o celular desbloqueado. Root em aparelho em funcionamento **não** é coberto na Fase 1: a chave do Keystore não exige autenticação do usuário, então quem tem root pode usá-la como o próprio app. A mitigação prevista é a expiração em 30 dias e "Apagar meus dados" — **meta, depende da C-10 (#131), ainda não implementada**. **Pilar B (Fase 2 da #136, depende da C-05):** a chave passa a ser liberada pelo PIN (Argon2id, envelope no Keystore). Risco residual: com o aparelho **e root**, a força bruta do PIN fica offline e o bloqueio por tentativas não a impede — um PIN de 4 dígitos cai em minutos, um de 6 em horas; por isso a C-05 exige PIN de **6 dígitos ou mais**, fora de uma lista de PINs triviais, o que encarece o ataque sem impedi-lo. Residual aceito pelo dono do projeto em 2026-11-04: com o aparelho e root, nenhum segredo guardado pelo app resiste; os dados do pilar B estão no servidor, a C-12 invalida a sessão e a C-10 expira o que fica local. Evolução: exigir autenticação do sistema na chave quando o aparelho tiver bloqueio de tela. Depois de C-12, a cifra local é a única proteção de um aparelho perdido que não volta a se conectar. A expiração em 30 dias e a opção "Apagar meus dados" são meta, dependem da C-10 (#131) e não estão implementadas. O wipe remoto (#81) não alcança aparelhos sem cadastro. +- **Dados locais do pilar A** (eventos de auditoria do aparelho, lembretes, respostas da autoavaliação): ficam só no aparelho. Os lembretes e o consentimento local já ficam cifrados (#136, abaixo). A trilha local de eventos existe desde a C-04 (#127), no mesmo banco cifrado (tabela `local_events`): guarda só o tipo do evento, o instante e a versão do motor — hoje um único tipo, a orientação "Ligar 192" exibida —, nunca as respostas, e não sai do aparelho. Desde a C-11 (#132), a autoavaliação do pilar A roda no aparelho, sem sessão e sem rede, e as respostas **não são gravadas** em lugar nenhum: ficam só na memória da tela e somem ao fechá-la. Com sessão (pilar B), ela continua indo ao servidor por `triage.evaluate`, que grava `triage_sessions` cifrado. Os dados locais do pilar A (lembretes, consentimento local e, desde a C-04, a trilha de eventos) ficam num único banco SQLCipher (AES-256), com chave aleatória guardada pelo Android Keystore, sem segredo do usuário (#136). O backup e a transferência entre aparelhos estão desligados; a notificação do lembrete não leva o texto do lembrete. Uma falha de leitura da chave ou de abertura do banco não apaga nada; só a chave comprovadamente ausente recomeça o banco vazio, e o app pede de novo a autorização de lembretes. **Limite do pilar A:** protege contra cópia dos arquivos (backup, ADB, extração do armazenamento, aparelho perdido desligado ou bloqueado), não contra quem usa o celular desbloqueado. Root em aparelho em funcionamento **não** é coberto na Fase 1: a chave do Keystore não exige autenticação do usuário, então quem tem root pode usá-la como o próprio app. A mitigação prevista é a expiração em 30 dias e "Apagar meus dados" — **meta, depende da C-10 (#131), ainda não implementada**. **Pilar B (Fase 2 da #136, depende da C-05):** a chave passa a ser liberada pelo PIN (Argon2id, envelope no Keystore). Risco residual: com o aparelho **e root**, a força bruta do PIN fica offline e o bloqueio por tentativas não a impede — um PIN de 4 dígitos cai em minutos, um de 6 em horas; por isso a C-05 exige PIN de **6 dígitos ou mais**, fora de uma lista de PINs triviais, o que encarece o ataque sem impedi-lo. Residual aceito pelo dono do projeto em 2026-11-04: com o aparelho e root, nenhum segredo guardado pelo app resiste; os dados do pilar B estão no servidor, a C-12 invalida a sessão e a C-10 expira o que fica local. Evolução: exigir autenticação do sistema na chave quando o aparelho tiver bloqueio de tela. Depois de C-12, a cifra local é a única proteção de um aparelho perdido que não volta a se conectar. A expiração em 30 dias e a opção "Apagar meus dados" são meta, dependem da C-10 (#131) e não estão implementadas. O wipe remoto (#81) não alcança aparelhos sem cadastro. - **Compartilhamento:** nenhum compartilhamento com terceiros de saúde no piloto (SAMU, UBS, Secretaria são Futuro). - **Operadores:** se os questionários do piloto (RF23) usarem formulário externo, esse serviço é operador de dados pessoais (nome `[A DEFINIR]`) e consta aqui e no TCLE (instrumentos e serviço: decisão proposta P-12, status: Proposta). - **Encerramento e anonimização:** conforme [`plano_piloto.md`](plano_piloto.md) (M-04). diff --git a/spec/requisitos_piloto.md b/spec/requisitos_piloto.md index dd8ff6ca..b053ca0e 100644 --- a/spec/requisitos_piloto.md +++ b/spec/requisitos_piloto.md @@ -28,7 +28,7 @@ alternativa gratuita. | RF01 | Autenticação passwordless (CPF + data de nascimento + OTP) | — | Futuro | Sim (gateway SMS pago) | Sem CPF e sem SMS no piloto (P-10); substituído por RF24. | | RF02 | Onboarding por QR Code (agente gera, participante escaneia) | B | Essencial | Não | Convite emitido pelo agente participante; base do RF24. | | RF03 | Envio do participante ao agente (no PRD, "botão de alerta de urgência") | B | Desejável | Não | No piloto: **pedido de contato com o agente participante**, sem rótulo de urgência. Maior gravidade na autoavaliação → só "Ligar 192", sem envio (P-09, C-04). INV-03 vale para o pedido (ver [INV-03 no piloto](#inv-03-no-piloto)). | -| RF04 | Formulário de autoavaliação estruturada (árvore de decisão) | A | Essencial **somente** com as três saídas de P-11; se P-11 for rejeitada, Futuro | Não | Orientação educativa com as saídas "Cuidar-se em casa", "Procurar atendimento" e "Ligar 192"; nunca "classificação de risco". No pilar A roda localmente, sem sessão e sem registro no servidor (C-11; hoje exige login). | +| RF04 | Formulário de autoavaliação estruturada (árvore de decisão) | A | Essencial **somente** com as três saídas de P-11; se P-11 for rejeitada, Futuro | Não | Orientação educativa com as saídas "Cuidar-se em casa", "Procurar atendimento" e "Ligar 192"; nunca "classificação de risco". No pilar A roda localmente, sem sessão e sem registro no servidor (C-11, #132: `SelfAssessmentEngine` no aparelho, com paridade das 64 combinações com o motor do backend provada em todo PR). | | RF05 | Painel de status da solicitação | B | Desejável | Não | Estados descritivos do pedido de contato; sem "Atendido" como promessa. | | RF06 | Lembretes de saúde locais | A | Essencial | Não | Sem servidor. | | RF07 | Login do agente (identificador + senha + TOTP) | B | Essencial | Não | Identificador emitido pela equipe do projeto, não por Secretaria. |