From f94a4ae97f21fb5bdbe98c4253ccdb3886dd35ed Mon Sep 17 00:00:00 2001
From: Leonardo <lmnohama@gmail.com>
Date: Thu, 21 May 2026 04:19:45 -0300
Subject: [PATCH] =?UTF-8?q?padronizacao:=20foundation=20Fase=200+0.5=20?=
 =?UTF-8?q?=E2=80=94=20blueprints=20+=20auditoria=20+=20clinical=5Fnotes?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Pre-MVP: 3 blueprints canonicos (repository, composable, quick-create
overlay), AUDIT_BASELINE com 51 divergencias em 6 modulos, estrategia
PADRONIZACAO de 4 fases, DESIGN_BILLING_ORCHESTRATOR. Schema clinical
notes pronto pra Fase B (4 migrations + seed templates). AgendaEvent
Dialog.vue.bak deletado (lixo de refator anterior).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 blueprints/composable-blueprint.md            |  514 +++
 blueprints/quick-create-overlay-blueprint.md  |  431 ++
 blueprints/repository-blueprint.md            |  379 ++
 .../20260520000001_clinical_notes_tables.sql  |  165 +
 .../20260520000002_clinical_notes_rls.sql     |  111 +
 ...260520000003_clinical_notes_versioning.sql |  117 +
 ...520000004_documents_clinical_note_link.sql |   46 +
 .../seed_040_clinical_note_templates.sql      |  151 +
 development/02-auditoria/AUDIT_BASELINE.md    |  302 ++
 .../DESIGN_BILLING_ORCHESTRATOR.md            |  480 +++
 development/02-auditoria/PADRONIZACAO.md      |  161 +
 .../components/AgendaEventDialog.vue.bak      | 3522 -----------------
 12 files changed, 2857 insertions(+), 3522 deletions(-)
 create mode 100644 blueprints/composable-blueprint.md
 create mode 100644 blueprints/quick-create-overlay-blueprint.md
 create mode 100644 blueprints/repository-blueprint.md
 create mode 100644 database-novo/migrations/20260520000001_clinical_notes_tables.sql
 create mode 100644 database-novo/migrations/20260520000002_clinical_notes_rls.sql
 create mode 100644 database-novo/migrations/20260520000003_clinical_notes_versioning.sql
 create mode 100644 database-novo/migrations/20260520000004_documents_clinical_note_link.sql
 create mode 100644 database-novo/seeds/seed_040_clinical_note_templates.sql
 create mode 100644 development/02-auditoria/AUDIT_BASELINE.md
 create mode 100644 development/02-auditoria/DESIGN_BILLING_ORCHESTRATOR.md
 create mode 100644 development/02-auditoria/PADRONIZACAO.md
 delete mode 100644 src/features/agenda/components/AgendaEventDialog.vue.bak

diff --git a/blueprints/composable-blueprint.md b/blueprints/composable-blueprint.md
new file mode 100644
index 0000000..6270ca7
--- /dev/null
+++ b/blueprints/composable-blueprint.md
@@ -0,0 +1,514 @@
+# Composable Blueprint
+
+> **Stack:** Vue 3 Composition API + Pinia (para state global) + Supabase via repository
+> **Canônicos:** `src/features/agenda/composables/useAgendaEvents.js`, `useAgendaClinicEvents.js`, `useAgendaSettings.js`
+> **Aplicável:** todo composable que orquestra estado reativo sobre uma repository
+
+---
+
+## 1. Princípio
+
+Composable é **wrapper fino** sobre a repository. Responsabilidade:
+- Manter **estado reativo** (data + loading + error)
+- Chamar a repository (delegação 1:1)
+- (Opcional) Cachear com stale-while-revalidate
+- (Opcional) Compor outros composables
+
+**Não faz:**
+- Lógica de banco direta (vai no repository)
+- Lógica de UI (vai no componente)
+- Manipulação de DOM
+- I/O direto fora do repository
+
+> Regra de ouro: **se o composable tem `from('...')` do Supabase, ele virou repository disfarçado — refatorar.**
+
+---
+
+## 2. Estrutura de arquivos
+
+```
+src/features/<modulo>/composables/
+├── use<Entity>.js              # CRUD básico (thin wrapper)
+├── use<Entity>Clinic.js        # variant clinic-scoped (se aplicável)
+├── use<Entity>Settings.js      # config/preferences (com cache opt-in)
+├── use<Entity>Lifecycle.js     # orquestrador de estados (se domain complexo)
+└── <entity>Helpers.js          # funções puras auxiliares (não-composable)
+```
+
+**Convenção de nome:** sempre `use<Entity>...`. Funções helpers de domínio NÃO usam prefixo `use` — não são composables.
+
+---
+
+## 3. State shape canônico
+
+Todo composable expõe **no mínimo** este shape:
+
+```js
+const rows = ref([]);       // ou single ref dependendo do domínio
+const loading = ref(false); // boolean
+const error = ref('');      // string vazia, não null — facilita v-if
+```
+
+**Decisões importantes:**
+
+| Refs | Tipo | Inicial | Por quê |
+|---|---|---|---|
+| `loading` | `boolean` | `false` | Padrão V3 — UI binda `:disabled="loading"` direto |
+| `error` | `string` | `''` (vazio) | `v-if="error"` é falsy-friendly; sem null check |
+| `rows`/data | `Array` ou objeto | `[]` ou `null` | Reset pra `[]` em erro de load — UI fica previsível |
+
+**Anti-pattern:** misturar `error = ref(null)` num composable e `error = ref('')` em outro. Canonize `''` no projeto inteiro.
+
+---
+
+## 4. Tipos de composable (3 patterns)
+
+### Tipo A — Thin wrapper (default) · referência: `useAgendaClinicEvents.js`
+
+CRUD direto, sem cache, com loading/error em TODA operação:
+
+```js
+import { ref } from 'vue';
+import { listX, createX, updateX, deleteX } from '@/features/<modulo>/services/<feature>Repository';
+
+export function useX() {
+    const rows = ref([]);
+    const loading = ref(false);
+    const error = ref('');
+
+    async function loadRange({ startISO, endISO, ...scope } = {}) {
+        loading.value = true;
+        error.value = '';
+        try {
+            rows.value = await listX({ startISO, endISO, ...scope });
+        } catch (e) {
+            error.value = e?.message || 'Falha ao carregar.';
+            rows.value = [];
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function create(payload, opts = {}) {
+        loading.value = true;
+        error.value = '';
+        try {
+            return await createX(payload, opts);
+        } catch (e) {
+            error.value = e?.message || 'Falha ao criar.';
+            throw e;  // ← re-throw: composable repassa o erro pro componente decidir
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function update(id, patch, opts = {}) { /* idem */ }
+    async function remove(id, opts = {}) { /* idem */ }
+
+    return { rows, loading, error, loadRange, create, update, remove };
+}
+```
+
+**Por que re-throw nas mutações?** Componente precisa saber se o `await` falhou pra:
+- Mostrar toast
+- Não fechar modal
+- Não navegar
+- Manter form com dados
+
+`error.value` é só pra estado reativo persistente. Mutação síncrona precisa de throw também.
+
+### Tipo B — Thin wrapper "extra-leve" · referência: `useAgendaEvents.js`
+
+Variant aceitável quando mutações **não precisam de loading**:
+
+```js
+async function create(payload) {
+    return createX(payload);  // ← repassa erro nativamente; componente try/catch
+}
+```
+
+**Quando usar:** UIs onde criar/editar tem feedback próprio (skeleton no item criado, optimistic UI, etc.). Default é o Tipo A.
+
+### Tipo C — Cache com stale-while-revalidate · referência: `useAgendaSettings.js`
+
+Para dados raros/pesados (settings, preferences, listas estáveis):
+
+```js
+import { ref } from 'vue';
+import { getX } from '../services/<feature>Repository';
+import { useMelissaCacheStore, MELISSA_CACHE_TTL } from '@/stores/melissaCacheStore';
+
+export function useX(opts = {}) {
+    const useCache = !!opts.cache;
+    const cache = useCache ? useMelissaCacheStore() : null;
+
+    const data = ref(null);
+    const loading = ref(false);
+    const error = ref('');
+
+    async function _doFetch() {
+        const result = await getX();
+        data.value = result;
+        if (cache) {
+            const key = result?.owner_id || 'anon';
+            cache.set('xKey', result, key);
+        }
+        return result;
+    }
+
+    async function load() {
+        if (cache) {
+            const cached = cache.get('xKey', undefined, MELISSA_CACHE_TTL.xKey);
+            if (cached) {
+                data.value = cached;
+                _doFetch().catch((e) => console.warn('[useX] revalidate', e));
+                return;
+            }
+        }
+
+        loading.value = true;
+        error.value = '';
+        try {
+            await _doFetch();
+        } catch (e) {
+            error.value = e?.message || 'Falha ao carregar.';
+            data.value = null;
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    return { data, loading, error, load };
+}
+```
+
+**Decisões do Tipo C:**
+
+- **`opts.cache` default `false`** — páginas de configuração que editam settings esperam mudança imediata após salvar, então cache opt-in.
+- **Cache key inclui scope** (`owner_id`/`tenant_id`) — invalida automaticamente em troca de usuário/tenant.
+- **TTL constants no store** — `MELISSA_CACHE_TTL.<feature>` (não hardcoded no composable).
+- **Stale-while-revalidate:** retorna cached SE existe + dispara fetch em background (sem await).
+- **Revalidate fail é warn**, não error — UI já tem dados válidos do cache.
+
+---
+
+## 5. Convenções de nomenclatura
+
+### Funções
+
+| Operação | Nome canônico | Variantes aceitas |
+|---|---|---|
+| Listar com filtro | `loadRange` / `loadMy<X>` | `load<Scope><Range>` |
+| Criar | `create` | `create<Scope>` (se houver ambiguidade) |
+| Atualizar | `update` | `update<Scope>` |
+| Remover | `remove` | `remove<Scope>` (nunca `delete` — palavra reservada) |
+| Recarregar | `refresh` | `reload` |
+| Limpar estado | `reset` / `clear` | — |
+
+**Scope sufixo** quando o composable serve múltiplos contextos: `loadMyRange` (terapeuta) vs `loadClinicRange` (admin).
+
+### State refs
+
+- `rows` — coleção principal (array)
+- `record` — single (quando faz sentido)
+- `data` — genérico (settings, config)
+- `loading` — boolean único; se há múltiplos `loading` (load vs save), nomear: `loadingList`, `saving`
+- `error` — string única; mesmo princípio: `loadError`, `saveError` se precisar
+
+---
+
+## 6. Anatomia padrão de uma operação `load*`
+
+```js
+async function loadXxx(args) {
+    // 1. Validação leve (early return, não throw)
+    if (!args?.required) return;
+
+    // 2. State flag
+    loading.value = true;
+    error.value = '';
+
+    try {
+        // 3. Delegate pra repository (UMA chamada — se múltiplas, Promise.all)
+        const result = await listX(args);
+
+        // 4. Mutate state
+        rows.value = result;
+    } catch (e) {
+        // 5. Erro humano + reset de data (UI fica previsível)
+        error.value = e?.message || 'Mensagem PT-BR genérica.';
+        rows.value = [];
+    } finally {
+        // 6. Sempre limpar loading
+        loading.value = false;
+    }
+}
+```
+
+**Por que early-return em vez de throw na validação?** Composable é wrapper — chamadas inválidas (ex: `ownerId` ainda não chegou no mount) não devem quebrar UI. Throw fica pra repository.
+
+---
+
+## 7. Múltiplos fetches paralelos
+
+Quando uma operação precisa de N queries:
+
+```js
+async function _doFetch() {
+    const [cfg, rules, profile] = await Promise.all([
+        getMyAgendaSettings(),
+        getMyWorkSchedule(),
+        getMyProfile()
+    ]);
+    settings.value = cfg;
+    workRules.value = rules;
+    profile.value = profile;
+}
+```
+
+**Regras:**
+- `Promise.all` (não `Promise.allSettled`) — falha de qualquer query falha a operação inteira
+- Exception: quando uma query é opcional/best-effort → `Promise.allSettled` + processa por result
+- **Nunca** sequenciar fetches independentes (await + await + await)
+
+---
+
+## 8. Composição de composables
+
+Composable pode usar outros composables, mas:
+
+```js
+// ✅ certo — composição estrutural
+export function useAgendaEventLifecycle() {
+    const events = useAgendaEvents();
+    const billing = useAgendaFinanceiro();
+    const settings = useAgendaSettings({ cache: true });
+
+    async function realizar(eventId) {
+        // orquestra os 3
+    }
+
+    return { ...events, realizar, ... };
+}
+
+// ❌ errado — não compor pra economizar 1 linha
+export function useOnlyToWrapList() {
+    const { rows, loadMyRange } = useAgendaEvents();
+    return { rows, loadMyRange };  // ← isso é um re-export inútil
+}
+```
+
+**Regra:** compõe quando há **orquestração**. Se é só forward, importa direto.
+
+---
+
+## 9. Anti-patterns (NÃO fazer)
+
+### ❌ Composable que tem `supabase.from('...')` direto
+
+```js
+// ❌ — violação de camadas
+export function useFoo() {
+    async function load() {
+        const { data } = await supabase.from('foo').select('*');
+    }
+}
+```
+
+✅ Move pra repository, composable só delega.
+
+### ❌ `error` ora `null`, ora `''`, ora `Error`
+
+Canonize `string` (default `''`). Errors do JS dão `e?.message || 'fallback PT-BR'`.
+
+### ❌ Não resetar `rows` em erro de load
+
+```js
+// ❌
+async function loadRange() {
+    try { rows.value = await listX(); } catch (e) { error.value = e.message; }
+    // rows.value mantém dados antigos = UI mostra coisa stale + alerta de erro
+}
+```
+
+✅ Reset `rows.value = []` no catch — UI fica determinística.
+
+### ❌ Não re-throw mutações
+
+```js
+// ❌
+async function create(payload) {
+    try { return await createX(payload); }
+    catch (e) { error.value = e.message; }
+    // componente faz `await create()` e nunca sabe que falhou
+}
+```
+
+✅ Re-throw após setar `error.value`.
+
+### ❌ `Promise.all` quando uma falha é aceitável
+
+Quando uma das queries pode falhar sem invalidar as outras, usar `Promise.allSettled`. Comum em listings que enriquece com lookups opcionais.
+
+### ❌ State global em variável módulo
+
+```js
+// ❌ — vaza entre componentes que compartilham o composable
+const rows = ref([]);
+export function useFoo() {
+    return { rows };
+}
+```
+
+✅ State sempre DENTRO da `function useFoo()`. Se precisar global, use Pinia store.
+
+### ❌ Composable que faz `watch` no próprio state pra "side effect"
+
+```js
+// ❌
+const rows = ref([]);
+watch(rows, () => { /* save algo */ });
+```
+
+✅ Mover `watch` pro componente — composable não decide quando salvar.
+
+**Exceção:** watch pra sincronizar com prop externa do composable (`watchEffect(() => loadRange(props.range))`) é OK.
+
+### ❌ Composable retornando objeto enorme
+
+Se o `return` tem 20+ chaves, o composable está fazendo coisa demais. Quebrar em N composables menores ou extrair Pinia store.
+
+---
+
+## 10. Cache store (Tipo C complementar)
+
+Quando criar um composable Tipo C, garantir que existe entry em:
+
+- `src/stores/melissaCacheStore.js` — `MELISSA_CACHE_TTL.<feature>` constante (TTL em ms)
+- `.get(key, scope, ttl)` retorna valor ou null
+- `.set(key, value, scope)` salva com timestamp
+- Invalidação manual: `.invalidate('<feature>')`
+
+**TTL guidelines:**
+
+| Tipo de dado | TTL sugerido |
+|---|---|
+| Settings/preferences | 5 min |
+| Listas estáveis (specialties, plans) | 30 min |
+| Catálogo (services, pricing) | 10 min |
+| Multi-tenant lookups | 5 min |
+| Anything user-edited | NÃO cachear (Tipo A) |
+
+---
+
+## 11. Checklist de auditoria por módulo
+
+Quando rodar `/audit-module <nome>`, validar cada composable:
+
+- [ ] Não tem `supabase.from(...)` direto — só importa da repository
+- [ ] State shape: `rows`/`data`, `loading: boolean`, `error: string`
+- [ ] `error` é string, default `''`
+- [ ] Reset de data em erro de load (`rows.value = []`)
+- [ ] Mutações re-throw após setar error.value
+- [ ] Nomenclatura: `loadRange`/`load<Scope>`, `create`, `update`, `remove`
+- [ ] `remove` não `delete` (palavra reservada)
+- [ ] Validação leve usa early-return (não throw)
+- [ ] Múltiplos fetches em `Promise.all` (não sequencial)
+- [ ] State DENTRO da `function use*()` (não em variável de módulo)
+- [ ] Sem `watch` em própria state pra side effect (mover pro componente)
+- [ ] Helpers de domínio em arquivo separado sem prefixo `use`
+- [ ] Se cacheia (Tipo C): `opts.cache` opt-in, default `false`; TTL em `MELISSA_CACHE_TTL`; cache key inclui scope
+- [ ] Return statement com chaves explícitas (não `return { ...state, ...actions }` opaco)
+- [ ] Return ≤ 15 chaves (>15 = composable fazendo coisa demais)
+
+Divergências viram items em `dev_auditoria_items` com:
+- `categoria`: `padronizacao`
+- `tag`: `padronizacao:<modulo>`
+- `severidade`: alta se camada quebrada (composable com `from()`); média se viola convenção (error null vs ''); baixa se cosmético (nome de função)
+
+---
+
+## 12. Exemplo completo (template)
+
+```js
+/*
+| Arquivo: src/features/patients/composables/usePatients.js
+*/
+import { ref } from 'vue';
+import {
+    listPatients,
+    createPatient,
+    updatePatient,
+    deletePatient
+} from '@/features/patients/services/patientsRepository';
+
+export function usePatients() {
+    const rows = ref([]);
+    const loading = ref(false);
+    const error = ref('');
+
+    async function loadRange({ search, status, tenantId } = {}) {
+        loading.value = true;
+        error.value = '';
+        try {
+            rows.value = await listPatients({ search, status, tenantId });
+        } catch (e) {
+            error.value = e?.message || 'Falha ao carregar pacientes.';
+            rows.value = [];
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function create(payload) {
+        loading.value = true;
+        error.value = '';
+        try {
+            return await createPatient(payload);
+        } catch (e) {
+            error.value = e?.message || 'Falha ao criar paciente.';
+            throw e;
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function update(id, patch) {
+        loading.value = true;
+        error.value = '';
+        try {
+            return await updatePatient(id, patch);
+        } catch (e) {
+            error.value = e?.message || 'Falha ao atualizar paciente.';
+            throw e;
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    async function remove(id) {
+        loading.value = true;
+        error.value = '';
+        try {
+            await deletePatient(id);
+        } catch (e) {
+            error.value = e?.message || 'Falha ao remover paciente.';
+            throw e;
+        } finally {
+            loading.value = false;
+        }
+    }
+
+    return { rows, loading, error, loadRange, create, update, remove };
+}
+```
+
+---
+
+## 13. Referências
+
+- Canônicos: `src/features/agenda/composables/useAgendaEvents.js`, `useAgendaClinicEvents.js`, `useAgendaSettings.js`
+- Repository pareado: `blueprints/repository-blueprint.md`
+- Cache store: `src/stores/melissaCacheStore.js`
+- Tracker: `dev_auditoria_items` com tag `padronizacao:<modulo>`
+- Estratégia: `development/02-auditoria/PADRONIZACAO.md`
diff --git a/blueprints/quick-create-overlay-blueprint.md b/blueprints/quick-create-overlay-blueprint.md
new file mode 100644
index 0000000..61691c2
--- /dev/null
+++ b/blueprints/quick-create-overlay-blueprint.md
@@ -0,0 +1,431 @@
+# Quick-Create Overlay Blueprint
+
+> **Status:** Pattern **universal**. Promovido de agenda-only em 2026-05-20 após audit baseline (`development/02-auditoria/AUDIT_BASELINE.md`) identificar 3 candidates já em produção fora da agenda.
+> **Stack:** Vue 3 + PrimeVue Dialog
+> **Canônicos:**
+> - `src/features/agenda/components/ServiceQuickCreateDialog.vue` (referência completa)
+> - `src/features/agenda/components/InsurancePlanQuickCreateDialog.vue`
+> - `src/features/agenda/components/InsurancePlanServiceQuickCreateDialog.vue`
+> **Legacy a refatorar (supabase direto, sem repository):**
+> - `src/components/CadastroRapidoMedico.vue` → migrar pra `features/medicos/components/` (módulo 1 da Fase 1)
+> - `src/components/CadastroRapidoConvenio.vue` → migrar pra `features/insurance/components/`
+> - `src/components/ComponentCadastroRapido.vue` → migrar pra path apropriado conforme dono da entidade
+
+---
+
+## 1. Princípio
+
+**Problema:** usuário está num fluxo (ex: agendar uma sessão) e precisa de uma entidade dependente que ainda não existe (serviço, convênio, plano). Navegar pra outra página significa **perder o contexto** do form em progresso.
+
+**Solução:** mini-dialog **por cima** do dialog/fluxo atual, com **campos mínimos** pra criar a entidade, e ao salvar **pré-seleciona** ela no select que disparou o quick-create.
+
+**Regra absoluta:** criar dependência faltante em **qualquer fluxo** deve **abrir overlay POR CIMA, nunca navegar pra fora**. Aplicável em todo o sistema desde a promoção do blueprint (2026-05-20). Origem do pattern: agenda (memória `feedback_agenda_inline_quick_create`, agora generalizada).
+
+---
+
+## 2. Quando aplicar (vs alternativas)
+
+| Situação | Solução |
+|---|---|
+| Fluxo crítico travado por dependência faltante (form em progresso) | **Quick-create overlay** ✅ |
+| Cadastro completo, com todos os campos | Página dedicada `/entity/new` ou Dialog full |
+| Apenas selecionar item existente | Select com busca; sem botão "+" |
+| Onboarding ou setup wizard | Não — fluxo é a página inteira, não um overlay |
+
+**Anti-uso:** quick-create NÃO é "shortcut pra criar do menu lateral". É **fallback contextual** quando o form atual depende de algo que falta. O parent **precisa estar pronto pra receber o evento `created`** e usar o ID.
+
+---
+
+## 3. Estrutura do componente `<Entity>QuickCreateDialog.vue`
+
+```vue
+<script setup>
+import { ref, watch } from 'vue';
+import { useToast } from 'primevue/usetoast';
+// CANÔNICO: importar da repository do feature dono da entidade.
+// LEGACY: 3 componentes em src/components/ usam supabase direto — refatorar quando módulo dono for tocado na Fase 1.
+import { createX } from '@/features/<feature>/services/<feature>Repository';
+
+const props = defineProps({
+    modelValue: { type: Boolean, default: false },
+    ownerId: { type: String, default: '' },
+    initialName: { type: String, default: '' }  // pré-preenche do search atual do select
+});
+const emit = defineEmits(['update:modelValue', 'created']);
+
+const toast = useToast();
+const tenantStore = useTenantStore();
+
+const visible = ref(props.modelValue);
+watch(() => props.modelValue, (v) => { visible.value = v; });
+watch(visible, (v) => emit('update:modelValue', v));
+
+const form = ref({ /* só campos MÍNIMOS obrigatórios + 1-2 opcionais úteis */ });
+const saving = ref(false);
+
+// Resetar form toda vez que abre
+watch(() => props.modelValue, (v) => {
+    if (v) form.value = { /* defaults + initialName */ };
+});
+
+const canSave = () => /* validação leve */;
+
+async function onSave() {
+    if (!canSave()) return;
+
+    saving.value = true;
+    try {
+        // Sanitize (trim + maxlength slice + nullif vazio) ANTES de chamar repository
+        const payload = {
+            name: form.value.name.trim().slice(0, 120),
+            // ...resto sanitizado
+        };
+
+        // Repository injeta owner_id (uid logado) + tenant_id (store) + faz uniqueness check
+        // e throw em erro. Quick-create só decide o que mostrar ao usuário.
+        const data = await createX(payload);
+
+        toast.add({ severity: 'success', summary: '<Entity> criado', life: 2200 });
+        emit('created', data);  // ← parent usa data.id pra pré-selecionar
+        visible.value = false;
+    } catch (e) {
+        // Repository pode throw com message conhecido (ex: "Nome em uso") — mostra como warn ou error
+        const isDup = /em uso|já existe|duplicate/i.test(e?.message || '');
+        toast.add({
+            severity: isDup ? 'warn' : 'error',
+            summary: isDup ? 'Nome em uso' : 'Falha ao criar',
+            detail: e?.message || 'Erro inesperado',
+            life: 4000
+        });
+    } finally {
+        saving.value = false;
+    }
+}
+</script>
+
+<!--
+LEGACY-NOTE (2026-05-20): os 3 quick-creates em src/components/ (CadastroRapidoMedico,
+CadastroRapidoConvenio, ComponentCadastroRapido) ainda usam supabase direto. Padrão acima
+é o CANÔNICO pós-promoção. Refator vai acontecer no módulo correspondente da Fase 1.
+-->
+
+<template>
+    <Dialog
+        v-model:visible="visible"
+        modal
+        :draggable="false"
+        :closable="!saving"
+        header="Novo <entity>"
+        class="w-[94vw] max-w-md"
+    >
+        <!-- Campos mínimos: 3-5 inputs, nada mais -->
+        <div class="flex flex-col gap-3 pt-1"> ... </div>
+
+        <template #footer>
+            <Button label="Cancelar" text :disabled="saving" @click="visible = false" />
+            <Button label="Salvar" :loading="saving" :disabled="!canSave()" @click="onSave" />
+        </template>
+    </Dialog>
+</template>
+```
+
+---
+
+## 4. Contrato canônico de props/emits
+
+### Props (sempre)
+
+| Prop | Tipo | Default | Função |
+|---|---|---|---|
+| `modelValue` | `Boolean` | `false` | Visibilidade do dialog. Two-way via `v-model`. |
+| `ownerId` | `String` | `''` | Owner_id (terapeuta). Default: usuário logado. |
+| `initialName` | `String` | `''` | Pré-preenche o campo nome com o search atual do select (UX win). |
+
+### Props (opcionais por entidade)
+
+- `parentId` (`String`) — quando a entidade tem hierarquia (ex: `plan_id` em `plan_service`)
+- `defaultDurationMin` (`Number`) — quando faz sentido herdar valor do contexto
+- Outras herdadas do contexto, **nunca** mais que 3 props extras (senão vira form pesado, não quick-create)
+
+### Emits
+
+| Evento | Payload | Quando |
+|---|---|---|
+| `update:modelValue` | `Boolean` | `v-model` two-way |
+| `created` | `Object` (row inserida completa) | Após insert bem-sucedido |
+
+**Nunca emitir** `cancelled`, `closed`, `error` — parent não precisa saber dessas distinções; `update:modelValue=false` cobre.
+
+---
+
+## 5. Integração no parent
+
+### Slot do botão `+` ao lado do select
+
+```vue
+<div class="flex gap-2 items-center">
+    <Select v-model="selectedServiceId" :options="services" optionLabel="name" optionValue="id" class="flex-1" />
+    <Button
+        icon="pi pi-plus"
+        v-tooltip.top="'Cadastrar novo serviço'"
+        severity="secondary"
+        size="small"
+        @click="openServiceQuickCreate"
+    />
+</div>
+```
+
+### Lock do dialog parent
+
+Parent **precisa** travar seu próprio `dismissableMask` e `closeOnEscape` enquanto qualquer quick-create child está aberto, senão clicar fora fecha tudo:
+
+```vue
+<Dialog
+    v-model:visible="parentVisible"
+    :dismissableMask="!anyChildDialogOpen"
+    :closeOnEscape="!anyChildDialogOpen"
+    ...
+>
+```
+
+```js
+const serviceQuickCreateOpen = ref(false);
+const insuranceQuickCreateOpen = ref(false);
+const anyChildDialogOpen = computed(() =>
+    serviceQuickCreateOpen.value || insuranceQuickCreateOpen.value
+);
+```
+
+### Renderização dos quick-creates DENTRO do parent
+
+```vue
+<!-- DENTRO do template do parent dialog, antes do </Dialog> -->
+<ServiceQuickCreateDialog
+    v-model="serviceQuickCreateOpen"
+    :owner-id="ownerId"
+    :initial-name="serviceSearchText"
+    @created="onServiceCreated"
+/>
+```
+
+### Handler `on<Entity>Created`
+
+```js
+function onServiceCreated(row) {
+    // 1. Inserir na lista local (sem re-fetch)
+    services.value = [row, ...services.value];
+    // 2. Pré-selecionar no select
+    selectedServiceId.value = row.id;
+    // 3. (Opcional) Focar o próximo campo
+    nextTick(() => priceInputRef.value?.focus());
+}
+```
+
+### Handler `openXQuickCreate`
+
+```js
+function openServiceQuickCreate() {
+    serviceSearchText.value = currentSearchInSelect.value;  // capture pra initialName
+    serviceQuickCreateOpen.value = true;
+}
+```
+
+---
+
+## 6. Convenções de UX
+
+### Campos mínimos absolutos
+
+Quick-create **não é cadastro completo**. Inclui só:
+- 1 campo obrigatório principal (nome)
+- 1-2 campos obrigatórios secundários (preço, duração)
+- 1 campo opcional (descrição)
+
+Resto (categorias, tags, configurações avançadas) edita depois em `/entity/:id`.
+
+### Maxlength visível
+
+```vue
+<InputText v-model="form.name" maxlength="120" />
+```
+
+Slice no save: `.trim().slice(0, 120)` — defesa em profundidade.
+
+### Botão "+" sempre `size="small"` `severity="secondary"`
+
+Discrição visual — não compete com CTA do dialog parent.
+
+### Toast em vez de inline error
+
+Mini-dialog não tem espaço pra banner de erro. Toast no canto superior direito (padrão PrimeVue) basta.
+
+### `autofocus` no primeiro input
+
+```vue
+<InputText autofocus v-model="form.name" />
+```
+
+Usuário já está em modo "digitar" — pular o clique no input.
+
+### `:loading="saving"` no botão Salvar
+
+Spinner + disabled simultâneo. PrimeVue já dá o efeito visual.
+
+---
+
+## 7. Anti-patterns (NÃO fazer)
+
+### ❌ Navegar pra rota nova no botão "+"
+
+```js
+// ❌ — destrói o form em progresso
+function openServiceQuickCreate() {
+    router.push('/saas/services/new');
+}
+```
+
+✅ Abre o overlay.
+
+### ❌ Quick-create que pede 10 campos
+
+Se a entidade exige cadastro complexo (campos condicionais, validações cruzadas, upload de arquivo), **não cabe num quick-create**. Use página dedicada e aceite que o usuário perde contexto. Ou crie um wizard.
+
+### ❌ Sem `dups check` antes do insert
+
+```js
+// ❌ — usuário clica 2x, cria duplicata silenciosa
+await supabase.from('services').insert(payload).select().single();
+```
+
+✅ `ilike` por `name` antes; aborta com warn toast.
+
+### ❌ Não emitir o objeto completo no `created`
+
+```js
+// ❌
+emit('created', { id: data.id });  // parent precisa de mais que id
+
+// ❌ pior ainda
+emit('created');  // parent não sabe o que foi criado
+```
+
+✅ `emit('created', data)` — row completa do banco.
+
+### ❌ Não capturar `initialName` do search atual
+
+Quando usuário digita "Sessão 50min" no select e clica "+", o `initialName=` deve já vir preenchido. Senão usuário re-digita.
+
+### ❌ Parent sem `anyChildDialogOpen` no lock
+
+Sem o lock, clicar fora do quick-create child fecha o parent inteiro. Bug clássico.
+
+### ❌ Re-fetch da lista após `created`
+
+```js
+// ❌ — round-trip desnecessário; o evento já trouxe o row
+async function onServiceCreated() {
+    await loadServices();
+}
+```
+
+✅ Inserir o `row` recebido direto na lista local; só re-fetch se houver lógica de ordenação complexa.
+
+### ❌ Múltiplos quick-creates abertos ao mesmo tempo
+
+Permitir abrir um quick-create de plano de saúde enquanto outro de serviço está aberto = stack visual confuso. Force fechar o atual antes de abrir o próximo, OU mantenha o lock no `anyChildDialogOpen` que cobre.
+
+---
+
+## 8. Sanitização (memória `feedback_sanitizacao`)
+
+Toda entrada de quick-create:
+
+```js
+const name = form.value.name?.trim().slice(0, 120) || null;
+const description = form.value.description?.trim().slice(0, 500) || null;
+const price = form.value.price != null ? Number(form.value.price) : null;
+```
+
+Padrão: `trim()` → `slice(maxlength)` → `nullif vazio` → cast tipo.
+
+Pro upload (não comum em quick-create, mas se houver): mime allowlist + size check antes de submitter.
+
+---
+
+## 9. Promotion History & Path Convention
+
+### Histórico
+
+- **2026-05-04** — Pattern nasceu em `features/agenda/` com 3 quick-creates (Service, InsurancePlan, InsurancePlanService). Documentado como **agenda-only** com promotion criteria explícito.
+- **2026-05-20** — Audit baseline identificou 3 candidates já em produção fora da agenda: `CadastroRapidoMedico.vue`, `CadastroRapidoConvenio.vue`, `ComponentCadastroRapido.vue` (todos `supabase` direto, em `src/components/`). Promotion criteria atingida 3×. **Blueprint promovido pra universal.**
+
+### Path convention pós-promoção
+
+| Caso | Path | Exemplo |
+|---|---|---|
+| Entidade pertence a 1 feature claro | `src/features/<feature>/components/<Entity>QuickCreateDialog.vue` | `features/medicos/components/MedicoQuickCreateDialog.vue` |
+| Entidade é cross-feature (raro) | `src/components/quick-create/<Entity>QuickCreateDialog.vue` | (nenhum hoje) |
+
+**Anti-pattern:** quick-create morando em `src/components/` raiz sem subpasta — perde discoverability e mistura com componentes utilitários.
+
+### Plano de migração dos 3 legacy
+
+Cada refator acontece **quando o módulo dono for tocado na Fase 1**:
+
+| Componente atual | Path destino | Quando | Fix obrigatório |
+|---|---|---|---|
+| `src/components/CadastroRapidoMedico.vue` | `src/features/medicos/components/MedicoQuickCreateDialog.vue` | Módulo 1 (Home/Components) — pode criar `features/medicos/` se ainda não existe | Migrar pra repository; usar `_tenantGuards` |
+| `src/components/CadastroRapidoConvenio.vue` | `src/features/insurance/components/InsurancePlanQuickCreateDialog.vue` (consolidar com o existente na agenda?) | Módulo 1 | Idem; **verificar se duplica `features/agenda/components/InsurancePlanQuickCreateDialog.vue`** |
+| `src/components/ComponentCadastroRapido.vue` | depende do que cria | Módulo 1 | Idem |
+
+### Boilerplate DRY (futuro, não-prioritário)
+
+Quando houver 5+ quick-creates seguindo o pattern, considerar:
+
+- `useQuickCreateLock()` composable que encapsula `anyChildDialogOpen` (DRY entre parent dialogs com 2+ children)
+- `<BaseQuickCreateDialog>` wrapper component com slots `#fields`, `#footer-extra` e props padrão
+
+**Não fazer agora** — 6 instâncias ainda é pouco pra inflar abstração. Pattern atual (cada quick-create standalone) é fácil de entender e copiar.
+
+---
+
+## 10. Checklist de auditoria
+
+Aplica-se a **todo quick-create do sistema** pós-promoção (2026-05-20):
+
+- [ ] Path correto (feature folder se entidade pertence a 1 feature; `src/components/quick-create/` se cross-feature)
+- [ ] Nome do arquivo: `<Entity>QuickCreateDialog.vue` (PascalCase)
+- [ ] Props canônicas: `modelValue`, `ownerId`, `initialName`
+- [ ] Emits canônicos: `update:modelValue`, `created`
+- [ ] `Dialog` com `modal`, `:draggable="false"`, `:closable="!saving"`
+- [ ] Form reset quando abre (`watch modelValue`)
+- [ ] Sanitização: `trim() + slice(maxlength) + nullif` ANTES de chamar repository
+- [ ] **Insert via repository** (não supabase direto) — repository injeta `owner_id`+`tenant_id` e faz uniqueness check
+- [ ] Toast feedback em success/warn/error (warn quando erro for "nome em uso", error caso contrário)
+- [ ] Emit `created` com row completo (não só id)
+- [ ] Parent: `anyChildDialogOpen` computed lock
+- [ ] Parent: `dismissableMask` e `closeOnEscape` bindados ao lock
+- [ ] Parent: handler `on<Entity>Created` insere row na lista local e pré-seleciona
+- [ ] Parent: `initialName` capturado do search atual do select
+- [ ] Botão "+": `size="small"` `severity="secondary"` `v-tooltip`
+- [ ] `autofocus` no primeiro input
+- [ ] `:loading="saving"` + `:disabled="!canSave()"` no Salvar
+- [ ] Máximo 3-5 inputs no form (senão não é quick-create — vira página dedicada)
+
+Divergências viram items em `dev_auditoria_items` com:
+- `categoria`: `padronizacao`
+- `tag`: `padronizacao:<modulo>` (módulo dono da entidade)
+- `severidade`: **alta** se usa supabase direto em vez de repository, ou viola lock (vaza dismiss); **média** se viola contrato (emits/props); **baixa** se cosmético
+
+---
+
+## 11. Referências
+
+- Canônicos: `src/features/agenda/components/ServiceQuickCreateDialog.vue`, `InsurancePlanQuickCreateDialog.vue`, `InsurancePlanServiceQuickCreateDialog.vue`
+- Parent integrador: `src/features/agenda/components/AgendaEventDialog.vue` (linhas ~3081-3107, ~3170, ~3274, ~3307)
+- Legacy a refatorar: `src/components/CadastroRapidoMedico.vue`, `CadastroRapidoConvenio.vue`, `ComponentCadastroRapido.vue`
+- Dialog base: `blueprints/dialog-blueprint.md`
+- Repository pareado: `blueprints/repository-blueprint.md`
+- Audit baseline: `development/02-auditoria/AUDIT_BASELINE.md` (3 candidates descobertos em 2026-05-20)
+- Memória: `feedback_agenda_inline_quick_create.md` (superseded — pattern agora universal), `feedback_sanitizacao.md`
+- Estratégia: `development/02-auditoria/PADRONIZACAO.md`
diff --git a/blueprints/repository-blueprint.md b/blueprints/repository-blueprint.md
new file mode 100644
index 0000000..08a1e51
--- /dev/null
+++ b/blueprints/repository-blueprint.md
@@ -0,0 +1,379 @@
+# Repository Blueprint
+
+> **Stack:** Supabase JS client + Vue 3 (Pinia stores)
+> **Canônico:** `src/features/agenda/services/` (validado em C1-C13 + análise sênior 2026-05-20)
+> **Aplicável:** todo módulo com acesso a tabela `*` com `tenant_id`
+
+---
+
+## 1. Princípio
+
+Camada **thin** entre Supabase e composables. **Funções puras** + **tenant guards** + **SELECT canônico**. Sem classes, sem state, sem singletons. Idempotente, testável, descartável.
+
+Composable orquestra estado e cache. **Repository só fala com o banco.**
+
+---
+
+## 2. Estrutura de arquivos
+
+```
+src/features/<modulo>/services/
+├── _tenantGuards.js              # SHARED entre repositories do feature
+├── <feature>Selects.js           # SELECT canônico + helpers de flatten
+├── <feature>Repository.js        # CRUD escopo terapeuta (owner_id = uid)
+└── <feature>ClinicRepository.js  # CRUD escopo clínica (se aplicável)
+```
+
+**Regra do `_tenantGuards.js`:** se o feature tem 2+ repositories (terapeuta + clínica), os guards saem pra arquivo compartilhado. Se só tem 1, pode ficar no topo do próprio repo.
+
+---
+
+## 3. Tenant guards canônicos
+
+Copiar **literal** de `src/features/agenda/services/_tenantGuards.js`:
+
+```js
+import { supabase } from '@/lib/supabase/client';
+
+export function assertTenantId(tenantId) {
+    if (!tenantId || tenantId === 'null' || tenantId === 'undefined') {
+        throw new Error('Tenant ativo inválido. Selecione a clínica/tenant antes de operar.');
+    }
+}
+
+export async function getUid() {
+    const { data, error } = await supabase.auth.getUser();
+    if (error) throw error;
+    const uid = data?.user?.id;
+    if (!uid) throw new Error('Usuário não autenticado.');
+    return uid;
+}
+
+export function assertIsoRange(startISO, endISO) {
+    if (!startISO || !endISO) throw new Error('Intervalo inválido (startISO/endISO).');
+}
+
+export function sanitizeOwnerIds(ownerIds) {
+    return (ownerIds || []).filter((id) => typeof id === 'string' && id && id !== 'null' && id !== 'undefined');
+}
+```
+
+**Por quê string `'null'`/`'undefined'`?** Vindo de URL params/localStorage stringificado, esses casos aparecem como string literal. Defesa em profundidade.
+
+---
+
+## 4. SELECT canônico
+
+**Extrair pra constante exportada.** Inline SELECT em 3 lugares = divergência sutil (FKs explícitas em uns, não em outros) = bug.
+
+```js
+/**
+ * Select canônico de <tabela> com joins.
+ *
+ * FKs explícitas (obrigatórias quando há múltiplas colunas apontando pra mesma tabela):
+ *   - <tabela>_<col>_fkey
+ */
+export const <FEATURE>_SELECT = `
+  id, owner_id, tenant_id, ...,
+  patients!<tabela>_<col>_fkey (
+    id, nome_completo, avatar_url, status
+  )
+`.trim();
+```
+
+E o **flatten helper** ao lado:
+
+```js
+/**
+ * Achata o aninhamento de patients dentro da row.
+ * Mantém ambas formas (flat + nested) pra compat com call sites variados.
+ */
+export function flatten<Feature>Row(r) {
+    if (!r) return r;
+    const patient = r.patients || null;
+    return {
+        ...r,
+        paciente_nome: patient?.nome_completo || r.paciente_nome || '',
+        paciente_avatar: patient?.avatar_url || r.paciente_avatar || '',
+        paciente_status: patient?.status || r.paciente_status || ''
+    };
+}
+```
+
+---
+
+## 5. Convenções de assinatura
+
+### Funções puras exportadas
+
+```js
+// ✅ certo
+export async function listMyEvents({ startISO, endISO, ownerId, tenantId } = {}) { ... }
+
+// ❌ errado — classe com state
+class AgendaRepository {
+  async list() { ... }
+}
+```
+
+### Args nomeados (destructure)
+
+Posicionais quebram com refator. Default `= {}` evita TypeError se chamarem sem args.
+
+### `tenantId` opcional → resolve via store
+
+Helper local no repository:
+
+```js
+import { useTenantStore } from '@/stores/tenantStore';
+import { assertTenantId } from './_tenantGuards';
+
+function resolveTenantId(tenantIdArg) {
+    const tenantStore = useTenantStore();
+    const tenantId = tenantIdArg || tenantStore.activeTenantId;
+    assertTenantId(tenantId);
+    return tenantId;
+}
+```
+
+Por que opcional? Composable pode passar `tenantId` explícito (testes, multi-tenant ops). Default chega via store.
+
+### Errors throw, nunca silent
+
+```js
+const { data, error } = await supabase.from('...').select(...);
+if (error) throw error;  // ✅
+// ❌ if (error) return null;
+// ❌ if (error) console.error(error);
+```
+
+Composable decide se faz `try/catch` + toast.
+
+### Ranges half-open
+
+```js
+// ✅ certo — half-open
+.gte('inicio_em', startISO).lt('inicio_em', endISO)
+
+// ❌ errado — fechado, gera off-by-one no último ms
+.gte('inicio_em', startISO).lte('inicio_em', endISO)
+```
+
+### Strip campos legados antes de insert/update
+
+```js
+// eslint-disable-next-line no-unused-vars
+const { paciente_id: _dropped, ...safePayload } = payload;
+```
+
+Quando há migração de coluna em andamento ou campo virtual no UI.
+
+---
+
+## 6. Operações CRUD — pattern
+
+### Create (owner-scoped)
+
+```js
+export async function create<Feature>(payload) {
+    if (!payload) throw new Error('Payload vazio.');
+    const uid = await getUid();
+    const tid = resolveTenantId();
+
+    const { paciente_id: _dropped, ...rest } = payload;
+    const insertPayload = { ...rest, tenant_id: tid, owner_id: uid };
+
+    const { data, error } = await supabase
+        .from('<tabela>')
+        .insert([insertPayload])
+        .select(<FEATURE>_SELECT)
+        .single();
+
+    if (error) throw error;
+    return flatten<Feature>Row(data);
+}
+```
+
+**Sempre:**
+- `tenant_id` injetado do store (não aceita do payload)
+- `owner_id` injetado do uid logado (ignora do payload — clinic-scoped variant pode aceitar explícito)
+- `.select(...)` + `.single()` retorna o registro completo
+
+### Update
+
+```js
+export async function update<Feature>(id, patch, { tenantId } = {}) {
+    if (!id) throw new Error('ID inválido.');
+    if (!patch) throw new Error('Patch vazio.');
+    const tid = resolveTenantId(tenantId);
+
+    const { paciente_id: _dropped, ...safePatch } = patch;
+
+    const { data, error } = await supabase
+        .from('<tabela>')
+        .update(safePatch)
+        .eq('id', id)
+        .eq('tenant_id', tid)  // ← defesa em profundidade — RLS reforça no banco
+        .select(<FEATURE>_SELECT)
+        .single();
+
+    if (error) throw error;
+    return flatten<Feature>Row(data);
+}
+```
+
+### Delete
+
+```js
+export async function delete<Feature>(id, { tenantId } = {}) {
+    if (!id) throw new Error('ID inválido.');
+    const tid = resolveTenantId(tenantId);
+
+    const { error } = await supabase
+        .from('<tabela>')
+        .delete()
+        .eq('id', id)
+        .eq('tenant_id', tid);
+
+    if (error) throw error;
+    return true;
+}
+```
+
+### List (range query)
+
+```js
+export async function list<Feature>({ startISO, endISO, ownerId, tenantId } = {}) {
+    assertIsoRange(startISO, endISO);
+    const uid = ownerId || (await getUid());
+    const tid = resolveTenantId(tenantId);
+
+    const { data, error } = await supabase
+        .from('<tabela>')
+        .select(<FEATURE>_SELECT)
+        .eq('tenant_id', tid)
+        .eq('owner_id', uid)
+        .gte('inicio_em', startISO)
+        .lt('inicio_em', endISO)
+        .order('inicio_em', { ascending: true });
+
+    if (error) throw error;
+    return (data || []).map(flatten<Feature>Row);
+}
+```
+
+### Clinic-scoped variant (admin/secretaria)
+
+Diferenças em relação ao owner-scoped:
+- `tenantId` **obrigatório explícito** (sem default via store — admin pode operar em qualquer tenant onde tem permissão)
+- `ownerIds` é array (multi-terapeuta no mosaico) → `sanitizeOwnerIds` antes do `.in(...)`
+- Permite definir `owner_id` no create (admin cria pra qualquer terapeuta do tenant)
+- Sem `excludeMirror` automático — depende do uso
+
+Referência: `src/features/agenda/services/agendaClinicRepository.js`
+
+---
+
+## 7. Anti-patterns (NÃO fazer)
+
+### ❌ Inline SELECT espalhado
+
+```js
+// ❌ em useFoo.js
+const { data } = await supabase.from('events').select('id, owner_id, patient_id, ...');
+
+// ❌ em fooRepository.js
+const { data } = await supabase.from('events').select('id, owner_id, ...');  // ← divergente
+```
+
+✅ Extrair pra `<feature>Selects.js`.
+
+### ❌ `useTenantStore()` em vários arquivos
+
+```js
+// ❌ em 5 arquivos diferentes
+const tenantStore = useTenantStore();
+const tid = tenantStore.activeTenantId;
+if (!tid) throw new Error('...');
+```
+
+✅ `resolveTenantId(tenantIdArg)` no topo do repo.
+
+### ❌ Aceitar `owner_id` do payload em create owner-scoped
+
+```js
+// ❌ permite usuário criar evento "de outro terapeuta"
+await supabase.from('events').insert({ ...payload, tenant_id: tid });
+```
+
+✅ Sempre injetar `owner_id` do uid logado (sobrescreve qualquer valor do payload).
+
+### ❌ `delete()` sem `.eq('tenant_id', tid)`
+
+```js
+// ❌ RLS deveria pegar, mas defesa em profundidade
+await supabase.from('events').delete().eq('id', id);
+```
+
+✅ Sempre filtra `.eq('tenant_id', tid)` mesmo com RLS ativo.
+
+### ❌ Return null em erro
+
+```js
+// ❌
+if (error) {
+    console.error(error);
+    return null;
+}
+```
+
+✅ `throw error`. Composable decide o que fazer.
+
+### ❌ Range fechado
+
+```js
+// ❌ — `2026-05-20` no `endISO` faz aparecer o dia inteiro do 20
+.gte('inicio_em', startISO).lte('inicio_em', endISO)
+```
+
+✅ Half-open: `.gte(...).lt(...)`. Caller passa `endISO` como o início do próximo bucket.
+
+### ❌ `paciente_id` (ou outro campo legado) chegando ao banco
+
+A migração já dropou colunas legadas. Strip no `safePayload` evita 400 silencioso.
+
+---
+
+## 8. Checklist de auditoria por módulo
+
+Quando rodar `/audit-module <nome>`, validar:
+
+- [ ] `services/_tenantGuards.js` existe (ou inline se 1 repo só)
+- [ ] `services/<feature>Selects.js` existe e exporta `<FEATURE>_SELECT`
+- [ ] `services/<feature>Repository.js` é pure functions (sem classe/state)
+- [ ] `resolveTenantId(tenantIdArg)` local — não `useTenantStore()` espalhado
+- [ ] Toda operação injeta `tenant_id` no insert/update
+- [ ] Create owner-scoped injeta `owner_id` do uid logado (ignora do payload)
+- [ ] Update/delete filtram `.eq('id').eq('tenant_id', tid)` — defesa em profundidade
+- [ ] FKs explícitas nos joins (`<tabela>!<fk_name>`)
+- [ ] Errors `throw`, nunca silent
+- [ ] Ranges half-open (`gte + lt`)
+- [ ] Strip de campos legados em insert/update
+- [ ] Clinic-scoped variant (se existe) sem default via store, tenantId obrigatório
+- [ ] `flatten<Feature>Row` definido se há joins aninhados
+
+Divergências viram items em `dev_auditoria_items` com:
+- `categoria`: `padronizacao`
+- `tag`: `padronizacao:<modulo>`
+- `severidade`: alta se viola segurança (tenant leak), média se viola convenção, baixa se cosmético
+- `arquivo`: path do arquivo
+- `solucao`: referência ao item do checklist
+
+---
+
+## 9. Referências
+
+- Canônico: `src/features/agenda/services/`
+- Variant clinic: `src/features/agenda/services/agendaClinicRepository.js`
+- Tracker: `dev_auditoria_items` com tag `padronizacao:<modulo>`
+- Decisões macro: `development/02-auditoria/PADRONIZACAO.md`
diff --git a/database-novo/migrations/20260520000001_clinical_notes_tables.sql b/database-novo/migrations/20260520000001_clinical_notes_tables.sql
new file mode 100644
index 0000000..c49c734
--- /dev/null
+++ b/database-novo/migrations/20260520000001_clinical_notes_tables.sql
@@ -0,0 +1,165 @@
+-- ============================================================================
+-- Cria tabelas do prontuário clínico
+-- ----------------------------------------------------------------------------
+-- Núcleo do prontuário: notas clínicas (anamnese, evolução, plano), com
+-- versionamento (audit trail) e templates (SOAP/DAP/BIRP/livre).
+--
+-- Decisões (sessão de modelagem 2026-05-20):
+--   • Tabela única `clinical_notes` discriminada por `note_type` (não 1 tabela
+--     por tipo). Templates customizáveis exigem flexibilidade.
+--   • `content_text` (livre) + `content_structured` (jsonb) coexistem na mesma
+--     row — UI prioriza conforme template; busca/edit rápido sempre tem text.
+--   • Versionamento via snapshot completo (não diff) em `clinical_note_versions`
+--     — restore trivial e audit visualization friendly. Trigger de versionamento
+--     criado em migration separada.
+--   • Instrumentos de avaliação (GAD-7, PHQ-9, etc) ficam pra Fase 2.
+--   • RLS: owner-only (terapeuta responsável). Sem clinic-wide read — CFP exige
+--     sigilo entre profissionais. Policies em migration separada.
+-- ============================================================================
+
+BEGIN;
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 1. clinical_notes — núcleo do prontuário
+-- ──────────────────────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS public.clinical_notes (
+    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    tenant_id uuid NOT NULL,
+    owner_id uuid NOT NULL,                              -- terapeuta responsável
+    patient_id uuid NOT NULL REFERENCES public.patients(id) ON DELETE RESTRICT,
+    session_event_id uuid REFERENCES public.agenda_eventos(id) ON DELETE SET NULL,
+    note_type text NOT NULL,
+    template_id uuid,                                    -- FK adicionada após criar templates
+    title text,
+    content_text text,
+    content_structured jsonb,
+    pinned boolean DEFAULT false NOT NULL,
+    is_draft boolean DEFAULT false NOT NULL,
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    updated_at timestamp with time zone DEFAULT now() NOT NULL,
+    created_by uuid NOT NULL,
+    updated_by uuid,
+    deleted_at timestamp with time zone,
+    deleted_by uuid,
+    CONSTRAINT clinical_notes_note_type_check CHECK (note_type IN (
+        'anamnese',
+        'evolucao_sessao',
+        'plano_terapeutico',
+        'observacao_livre',
+        'resumo_caso'
+    )),
+    CONSTRAINT clinical_notes_content_present_check CHECK (
+        content_text IS NOT NULL OR content_structured IS NOT NULL
+    )
+);
+
+COMMENT ON TABLE public.clinical_notes IS
+    'Notas clínicas do prontuário (anamnese, evolução de sessão, plano, observações). Owner-only via RLS — CFP exige sigilo.';
+COMMENT ON COLUMN public.clinical_notes.session_event_id IS
+    'Sessão associada (quando aplicável). Anamnese/plano/resumo podem ter NULL.';
+COMMENT ON COLUMN public.clinical_notes.content_text IS
+    'Conteúdo em texto livre (sempre disponível pra busca/edit rápido).';
+COMMENT ON COLUMN public.clinical_notes.content_structured IS
+    'Conteúdo em formato estruturado quando há template ativo (jsonb dos campos preenchidos).';
+
+CREATE INDEX IF NOT EXISTS idx_clinical_notes_patient_recent
+    ON public.clinical_notes (tenant_id, patient_id, created_at DESC)
+    WHERE deleted_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_clinical_notes_owner
+    ON public.clinical_notes (owner_id)
+    WHERE deleted_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_clinical_notes_session
+    ON public.clinical_notes (session_event_id)
+    WHERE session_event_id IS NOT NULL AND deleted_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_clinical_notes_type
+    ON public.clinical_notes (tenant_id, patient_id, note_type)
+    WHERE deleted_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_clinical_notes_pinned
+    ON public.clinical_notes (tenant_id, patient_id)
+    WHERE pinned = true AND deleted_at IS NULL;
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 2. clinical_note_versions — audit trail (snapshot completo)
+-- ──────────────────────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS public.clinical_note_versions (
+    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    note_id uuid NOT NULL REFERENCES public.clinical_notes(id) ON DELETE CASCADE,
+    tenant_id uuid NOT NULL,
+    version_number integer NOT NULL,
+    title text,
+    content_text text,
+    content_structured jsonb,
+    change_reason text,                                  -- 'criacao' | 'edicao' | livre
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    created_by uuid NOT NULL,
+    CONSTRAINT clinical_note_versions_unique UNIQUE (note_id, version_number)
+);
+
+COMMENT ON TABLE public.clinical_note_versions IS
+    'Snapshot completo de cada versão de clinical_notes. Criado via trigger AFTER INSERT OR UPDATE.';
+
+CREATE INDEX IF NOT EXISTS idx_clinical_note_versions_recent
+    ON public.clinical_note_versions (note_id, version_number DESC);
+CREATE INDEX IF NOT EXISTS idx_clinical_note_versions_audit
+    ON public.clinical_note_versions (created_by, created_at DESC);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 3. clinical_note_templates — templates SOAP/DAP/BIRP/anamnese padrão
+-- ──────────────────────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS public.clinical_note_templates (
+    id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    tenant_id uuid,                                      -- NULL = template global do sistema
+    owner_id uuid,                                       -- NULL = template do tenant inteiro
+    key text NOT NULL,                                   -- 'soap', 'dap', 'birp', 'anamnese_padrao', ...
+    name text NOT NULL,
+    note_type text NOT NULL,
+    description text,
+    structure jsonb NOT NULL,                            -- [{key, label, type, required, hint}]
+    is_system boolean DEFAULT false NOT NULL,
+    is_global boolean DEFAULT false NOT NULL,
+    active boolean DEFAULT true NOT NULL,
+    created_at timestamp with time zone DEFAULT now() NOT NULL,
+    updated_at timestamp with time zone DEFAULT now() NOT NULL,
+    CONSTRAINT clinical_note_templates_note_type_check CHECK (note_type IN (
+        'anamnese',
+        'evolucao_sessao',
+        'plano_terapeutico',
+        'observacao_livre',
+        'resumo_caso'
+    )),
+    CONSTRAINT clinical_note_templates_scope_check CHECK (
+        -- Sistema: ambos NULL e is_system=true
+        -- Tenant-wide: tenant_id presente, owner_id NULL
+        -- Owner: ambos presentes
+        (is_system = true AND tenant_id IS NULL AND owner_id IS NULL)
+        OR (is_system = false AND tenant_id IS NOT NULL)
+    )
+);
+
+COMMENT ON TABLE public.clinical_note_templates IS
+    'Templates de notas clínicas. Escopo: sistema (is_system, sem tenant), tenant-wide (tenant_id sem owner), owner (ambos).';
+
+CREATE INDEX IF NOT EXISTS idx_clinical_note_templates_active
+    ON public.clinical_note_templates (note_type)
+    WHERE active = true;
+CREATE INDEX IF NOT EXISTS idx_clinical_note_templates_tenant
+    ON public.clinical_note_templates (tenant_id, note_type)
+    WHERE tenant_id IS NOT NULL AND active = true;
+CREATE INDEX IF NOT EXISTS idx_clinical_note_templates_owner
+    ON public.clinical_note_templates (owner_id, note_type)
+    WHERE owner_id IS NOT NULL AND active = true;
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 4. FK de clinical_notes.template_id (criada agora que templates existe)
+-- ──────────────────────────────────────────────────────────────────────────
+
+ALTER TABLE public.clinical_notes
+    ADD CONSTRAINT clinical_notes_template_fkey
+    FOREIGN KEY (template_id)
+    REFERENCES public.clinical_note_templates(id)
+    ON DELETE SET NULL;
+
+COMMIT;
diff --git a/database-novo/migrations/20260520000002_clinical_notes_rls.sql b/database-novo/migrations/20260520000002_clinical_notes_rls.sql
new file mode 100644
index 0000000..e4e71d3
--- /dev/null
+++ b/database-novo/migrations/20260520000002_clinical_notes_rls.sql
@@ -0,0 +1,111 @@
+-- ============================================================================
+-- RLS policies do prontuário clínico
+-- ----------------------------------------------------------------------------
+-- Padrão MAIS RESTRITIVO que agenda — CFP exige sigilo profissional entre
+-- terapeutas do mesmo tenant. Default: APENAS o owner (terapeuta responsável)
+-- lê e escreve. Sem clinic-wide read.
+--
+-- Compartilhamento com supervisor / outro terapeuta vai requerer policy
+-- específica baseada em tabela `clinical_note_shares` (Fase 2).
+--
+-- Templates seguem regra mais aberta:
+--   • Sistema (is_system): todos authenticated leem
+--   • Tenant-wide (tenant_id): membros do tenant leem; tenant_admin edita
+--   • Owner: só o owner lê/edita
+-- ============================================================================
+
+BEGIN;
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- clinical_notes — owner only
+-- ──────────────────────────────────────────────────────────────────────────
+
+ALTER TABLE public.clinical_notes ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY clinical_notes_owner_select
+    ON public.clinical_notes FOR SELECT TO authenticated
+    USING (owner_id = auth.uid() AND deleted_at IS NULL);
+
+CREATE POLICY clinical_notes_owner_insert
+    ON public.clinical_notes FOR INSERT TO authenticated
+    WITH CHECK (
+        owner_id = auth.uid()
+        AND public.is_tenant_member(tenant_id)
+    );
+
+CREATE POLICY clinical_notes_owner_update
+    ON public.clinical_notes FOR UPDATE TO authenticated
+    USING (owner_id = auth.uid())
+    WITH CHECK (owner_id = auth.uid());
+
+-- DELETE só por soft-delete (UPDATE deleted_at). Hard delete bloqueado em RLS.
+-- Backup/admin pode dropar via psql -U supabase_admin se preciso.
+CREATE POLICY clinical_notes_no_hard_delete
+    ON public.clinical_notes FOR DELETE TO authenticated
+    USING (false);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- clinical_note_versions — read-only pelo owner da nota
+-- ──────────────────────────────────────────────────────────────────────────
+
+ALTER TABLE public.clinical_note_versions ENABLE ROW LEVEL SECURITY;
+
+CREATE POLICY clinical_note_versions_owner_select
+    ON public.clinical_note_versions FOR SELECT TO authenticated
+    USING (
+        EXISTS (
+            SELECT 1 FROM public.clinical_notes cn
+            WHERE cn.id = clinical_note_versions.note_id
+              AND cn.owner_id = auth.uid()
+        )
+    );
+
+-- INSERT só via trigger (SECURITY DEFINER). Sem policy de UPDATE/DELETE —
+-- versões são imutáveis. Trigger usa role bypass.
+CREATE POLICY clinical_note_versions_no_write
+    ON public.clinical_note_versions FOR INSERT TO authenticated
+    WITH CHECK (false);
+CREATE POLICY clinical_note_versions_no_update
+    ON public.clinical_note_versions FOR UPDATE TO authenticated
+    USING (false);
+CREATE POLICY clinical_note_versions_no_delete
+    ON public.clinical_note_versions FOR DELETE TO authenticated
+    USING (false);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- clinical_note_templates — escopo escalonado
+-- ──────────────────────────────────────────────────────────────────────────
+
+ALTER TABLE public.clinical_note_templates ENABLE ROW LEVEL SECURITY;
+
+-- SELECT: sistema (qualquer authenticated) + tenant-wide (membros) + owner (próprio)
+CREATE POLICY clinical_note_templates_select
+    ON public.clinical_note_templates FOR SELECT TO authenticated
+    USING (
+        active = true
+        AND (
+            is_system = true
+            OR (tenant_id IS NOT NULL AND public.is_tenant_member(tenant_id))
+        )
+    );
+
+-- INSERT/UPDATE/DELETE: só owner ou tenant_admin do tenant
+-- Templates do sistema (is_system) nunca alteráveis via UI — só via seed/migration.
+CREATE POLICY clinical_note_templates_owner_write
+    ON public.clinical_note_templates TO authenticated
+    USING (
+        is_system = false
+        AND (
+            owner_id = auth.uid()
+            OR (owner_id IS NULL AND public.is_tenant_admin(tenant_id))
+        )
+    )
+    WITH CHECK (
+        is_system = false
+        AND (
+            owner_id = auth.uid()
+            OR (owner_id IS NULL AND public.is_tenant_admin(tenant_id))
+        )
+    );
+
+COMMIT;
diff --git a/database-novo/migrations/20260520000003_clinical_notes_versioning.sql b/database-novo/migrations/20260520000003_clinical_notes_versioning.sql
new file mode 100644
index 0000000..7ff8ae7
--- /dev/null
+++ b/database-novo/migrations/20260520000003_clinical_notes_versioning.sql
@@ -0,0 +1,117 @@
+-- ============================================================================
+-- Trigger de versionamento automático de clinical_notes
+-- ----------------------------------------------------------------------------
+-- A cada INSERT ou UPDATE relevante em clinical_notes, cria snapshot completo
+-- em clinical_note_versions. Função é SECURITY DEFINER pra bypassar a RLS
+-- (que bloqueia INSERT direto em clinical_note_versions).
+--
+-- Versionamento dispara em:
+--   • INSERT — registra criação (version_number = 1)
+--   • UPDATE em content_text, content_structured ou title — registra edição
+--
+-- Mudanças em pinned/is_draft NÃO disparam versionamento (mudança de UI/state,
+-- não de conteúdo).
+-- ============================================================================
+
+BEGIN;
+
+CREATE OR REPLACE FUNCTION public.fn_clinical_note_version()
+RETURNS trigger
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path = public
+AS $$
+DECLARE
+    next_version integer;
+    reason text;
+BEGIN
+    SELECT COALESCE(MAX(version_number), 0) + 1
+      INTO next_version
+      FROM public.clinical_note_versions
+     WHERE note_id = NEW.id;
+
+    IF TG_OP = 'INSERT' THEN
+        reason := 'criacao';
+    ELSIF TG_OP = 'UPDATE' THEN
+        IF NEW.deleted_at IS NOT NULL AND OLD.deleted_at IS NULL THEN
+            reason := 'soft_delete';
+        ELSIF NEW.deleted_at IS NULL AND OLD.deleted_at IS NOT NULL THEN
+            reason := 'restore';
+        ELSE
+            reason := 'edicao';
+        END IF;
+    ELSE
+        reason := 'desconhecido';
+    END IF;
+
+    INSERT INTO public.clinical_note_versions (
+        note_id,
+        tenant_id,
+        version_number,
+        title,
+        content_text,
+        content_structured,
+        change_reason,
+        created_at,
+        created_by
+    ) VALUES (
+        NEW.id,
+        NEW.tenant_id,
+        next_version,
+        NEW.title,
+        NEW.content_text,
+        NEW.content_structured,
+        reason,
+        now(),
+        COALESCE(NEW.updated_by, NEW.created_by)
+    );
+
+    RETURN NEW;
+END;
+$$;
+
+COMMENT ON FUNCTION public.fn_clinical_note_version() IS
+    'Snapshot completo de clinical_notes a cada INSERT/UPDATE relevante. SECURITY DEFINER bypassa RLS pra escrever em clinical_note_versions (que bloqueia INSERT direto).';
+
+CREATE TRIGGER trg_clinical_notes_version_insert
+    AFTER INSERT ON public.clinical_notes
+    FOR EACH ROW
+    EXECUTE FUNCTION public.fn_clinical_note_version();
+
+CREATE TRIGGER trg_clinical_notes_version_update
+    AFTER UPDATE OF content_text, content_structured, title, deleted_at
+    ON public.clinical_notes
+    FOR EACH ROW
+    WHEN (
+        OLD.content_text IS DISTINCT FROM NEW.content_text
+        OR OLD.content_structured IS DISTINCT FROM NEW.content_structured
+        OR OLD.title IS DISTINCT FROM NEW.title
+        OR OLD.deleted_at IS DISTINCT FROM NEW.deleted_at
+    )
+    EXECUTE FUNCTION public.fn_clinical_note_version();
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- Trigger para updated_at automático
+-- ──────────────────────────────────────────────────────────────────────────
+
+CREATE OR REPLACE FUNCTION public.fn_clinical_notes_updated_at()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    NEW.updated_at := now();
+    RETURN NEW;
+END;
+$$;
+
+CREATE TRIGGER trg_clinical_notes_updated_at
+    BEFORE UPDATE ON public.clinical_notes
+    FOR EACH ROW
+    EXECUTE FUNCTION public.fn_clinical_notes_updated_at();
+
+CREATE TRIGGER trg_clinical_note_templates_updated_at
+    BEFORE UPDATE ON public.clinical_note_templates
+    FOR EACH ROW
+    EXECUTE FUNCTION public.fn_clinical_notes_updated_at();
+
+COMMIT;
diff --git a/database-novo/migrations/20260520000004_documents_clinical_note_link.sql b/database-novo/migrations/20260520000004_documents_clinical_note_link.sql
new file mode 100644
index 0000000..1d2b1fd
--- /dev/null
+++ b/database-novo/migrations/20260520000004_documents_clinical_note_link.sql
@@ -0,0 +1,46 @@
+-- ============================================================================
+-- Liga documents a clinical_notes (preenche FK órfã)
+-- ----------------------------------------------------------------------------
+-- A coluna `documents.session_note_id` existia desde antes apontando pra uma
+-- tabela `session_notes` que nunca foi criada. Agora que `clinical_notes`
+-- existe e abrange anamnese/evolução/plano (não só sessão), renomeia pra
+-- `clinical_note_id` e adiciona FK constraint.
+--
+-- PRÉ-CHECK: a query abaixo deve retornar 0 antes de rodar esta migration.
+--   SELECT count(*) FROM public.documents WHERE session_note_id IS NOT NULL;
+-- Se houver dados, eles são órfãos (referenciam tabela inexistente) — limpar
+-- antes de adicionar a FK constraint, ou ela falha.
+-- ============================================================================
+
+BEGIN;
+
+-- 1. Limpa eventuais órfãos (FK nunca foi enforced, mas valor pode ter sido
+--    setado por código no front antes da migration). Defesa em profundidade.
+UPDATE public.documents
+   SET session_note_id = NULL
+ WHERE session_note_id IS NOT NULL
+   AND NOT EXISTS (
+       SELECT 1 FROM public.clinical_notes cn
+        WHERE cn.id = documents.session_note_id
+   );
+
+-- 2. Rename
+ALTER TABLE public.documents
+    RENAME COLUMN session_note_id TO clinical_note_id;
+
+-- 3. FK constraint
+ALTER TABLE public.documents
+    ADD CONSTRAINT documents_clinical_note_fkey
+    FOREIGN KEY (clinical_note_id)
+    REFERENCES public.clinical_notes(id)
+    ON DELETE SET NULL;
+
+-- 4. Index pra reverse lookup (documentos de uma nota)
+CREATE INDEX IF NOT EXISTS idx_documents_clinical_note
+    ON public.documents (clinical_note_id)
+    WHERE clinical_note_id IS NOT NULL AND deleted_at IS NULL;
+
+COMMENT ON COLUMN public.documents.clinical_note_id IS
+    'Vínculo opcional a uma nota clínica (anexar PDF a anamnese/evolução). Renomeado de session_note_id em 2026-05-20.';
+
+COMMIT;
diff --git a/database-novo/seeds/seed_040_clinical_note_templates.sql b/database-novo/seeds/seed_040_clinical_note_templates.sql
new file mode 100644
index 0000000..69c04ec
--- /dev/null
+++ b/database-novo/seeds/seed_040_clinical_note_templates.sql
@@ -0,0 +1,151 @@
+-- ============================================================================
+-- Seed dos templates do sistema de prontuário clínico
+-- ----------------------------------------------------------------------------
+-- Templates is_system=true, sem tenant_id, sem owner_id.
+-- Cobrem os 4 tipos mais comuns de nota clínica em psicologia:
+--   • Anamnese padrão CFP-style
+--   • Evolução: SOAP / DAP / BIRP
+--   • Plano terapêutico padrão
+--
+-- structure jsonb segue schema:
+--   [
+--     { key, label, type, required?, hint?, options? },
+--     ...
+--   ]
+-- type: 'text' | 'textarea' | 'select' | 'date' | 'multiselect'
+-- ============================================================================
+
+BEGIN;
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 1. Anamnese padrão (CFP)
+-- ──────────────────────────────────────────────────────────────────────────
+INSERT INTO public.clinical_note_templates (
+    key, name, note_type, description, structure, is_system, is_global, active
+) VALUES (
+    'anamnese_padrao',
+    'Anamnese Padrão',
+    'anamnese',
+    'Estrutura padrão de anamnese clínica em psicologia. Pode ser preenchida em 1-3 sessões iniciais.',
+    '[
+        {"key": "queixa_principal", "label": "Queixa principal", "type": "textarea", "required": true, "hint": "O que trouxe o paciente à terapia"},
+        {"key": "historia_queixa", "label": "História da queixa", "type": "textarea", "hint": "Quando começou, evolução, fatores agravantes/atenuantes"},
+        {"key": "historia_vida", "label": "História de vida", "type": "textarea", "hint": "Infância, adolescência, eventos marcantes"},
+        {"key": "antecedentes_psicologicos", "label": "Antecedentes psicológicos", "type": "textarea", "hint": "Tratamentos anteriores, medicações, internações"},
+        {"key": "antecedentes_medicos", "label": "Antecedentes médicos", "type": "textarea", "hint": "Doenças, cirurgias, medicações em uso"},
+        {"key": "antecedentes_familiares", "label": "Antecedentes familiares", "type": "textarea", "hint": "Histórico familiar de transtornos psicológicos/psiquiátricos"},
+        {"key": "vida_atual_relacionamentos", "label": "Relacionamentos atuais", "type": "textarea"},
+        {"key": "vida_atual_trabalho_estudo", "label": "Trabalho / estudo atual", "type": "textarea"},
+        {"key": "hipoteses_iniciais", "label": "Hipóteses iniciais", "type": "textarea", "hint": "Hipóteses do terapeuta — não compartilhar com paciente"},
+        {"key": "plano_inicial", "label": "Plano terapêutico inicial", "type": "textarea"}
+    ]'::jsonb,
+    true,
+    true,
+    true
+);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 2. Evolução SOAP (Subjective, Objective, Assessment, Plan)
+-- ──────────────────────────────────────────────────────────────────────────
+INSERT INTO public.clinical_note_templates (
+    key, name, note_type, description, structure, is_system, is_global, active
+) VALUES (
+    'soap',
+    'Evolução SOAP',
+    'evolucao_sessao',
+    'Padrão internacional: Subjetivo (relato do paciente), Objetivo (observações), Avaliação (análise), Plano (próximos passos).',
+    '[
+        {"key": "subjetivo", "label": "S — Subjetivo", "type": "textarea", "required": true, "hint": "O que o paciente relatou; humor; queixas verbalizadas"},
+        {"key": "objetivo", "label": "O — Objetivo", "type": "textarea", "hint": "Observações do terapeuta: comportamento, afeto, aparência, postura"},
+        {"key": "avaliacao", "label": "A — Avaliação", "type": "textarea", "required": true, "hint": "Análise clínica, hipóteses, evolução"},
+        {"key": "plano", "label": "P — Plano", "type": "textarea", "required": true, "hint": "Intervenções planejadas, tarefas, foco da próxima sessão"}
+    ]'::jsonb,
+    true,
+    true,
+    true
+);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 3. Evolução DAP (Data, Assessment, Plan)
+-- ──────────────────────────────────────────────────────────────────────────
+INSERT INTO public.clinical_note_templates (
+    key, name, note_type, description, structure, is_system, is_global, active
+) VALUES (
+    'dap',
+    'Evolução DAP',
+    'evolucao_sessao',
+    'Mais conciso que SOAP: Dados (relato + observações), Avaliação, Plano.',
+    '[
+        {"key": "dados", "label": "D — Dados", "type": "textarea", "required": true, "hint": "Relato + observações em texto único"},
+        {"key": "avaliacao", "label": "A — Avaliação", "type": "textarea", "required": true},
+        {"key": "plano", "label": "P — Plano", "type": "textarea", "required": true}
+    ]'::jsonb,
+    true,
+    true,
+    true
+);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 4. Evolução BIRP (Behavior, Intervention, Response, Plan)
+-- ──────────────────────────────────────────────────────────────────────────
+INSERT INTO public.clinical_note_templates (
+    key, name, note_type, description, structure, is_system, is_global, active
+) VALUES (
+    'birp',
+    'Evolução BIRP',
+    'evolucao_sessao',
+    'Foco em intervenção: Comportamento observado, Intervenção aplicada, Resposta do paciente, Plano.',
+    '[
+        {"key": "behavior", "label": "B — Comportamento", "type": "textarea", "required": true, "hint": "Comportamento/queixa observada na sessão"},
+        {"key": "intervention", "label": "I — Intervenção", "type": "textarea", "required": true, "hint": "Técnicas ou abordagens aplicadas pelo terapeuta"},
+        {"key": "response", "label": "R — Resposta", "type": "textarea", "required": true, "hint": "Como o paciente respondeu à intervenção"},
+        {"key": "plano", "label": "P — Plano", "type": "textarea", "required": true}
+    ]'::jsonb,
+    true,
+    true,
+    true
+);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 5. Evolução livre (CFP-style — texto único)
+-- ──────────────────────────────────────────────────────────────────────────
+INSERT INTO public.clinical_note_templates (
+    key, name, note_type, description, structure, is_system, is_global, active
+) VALUES (
+    'evolucao_livre',
+    'Evolução Livre',
+    'evolucao_sessao',
+    'Texto único, sem estrutura — pra quem prefere prosa contínua estilo CFP tradicional.',
+    '[
+        {"key": "evolucao", "label": "Evolução", "type": "textarea", "required": true, "hint": "Texto único descrevendo a sessão"}
+    ]'::jsonb,
+    true,
+    true,
+    true
+);
+
+-- ──────────────────────────────────────────────────────────────────────────
+-- 6. Plano terapêutico padrão
+-- ──────────────────────────────────────────────────────────────────────────
+INSERT INTO public.clinical_note_templates (
+    key, name, note_type, description, structure, is_system, is_global, active
+) VALUES (
+    'plano_terapeutico_padrao',
+    'Plano Terapêutico Padrão',
+    'plano_terapeutico',
+    'Estrutura básica de plano: objetivos, estratégia, recursos, prazo estimado.',
+    '[
+        {"key": "objetivos_gerais", "label": "Objetivos gerais", "type": "textarea", "required": true, "hint": "O que o paciente quer alcançar"},
+        {"key": "objetivos_especificos", "label": "Objetivos específicos / metas", "type": "textarea", "hint": "Metas mensuráveis"},
+        {"key": "estrategia_terapeutica", "label": "Estratégia terapêutica", "type": "textarea", "required": true, "hint": "Abordagem teórica, técnicas previstas"},
+        {"key": "recursos_indicados", "label": "Recursos / intervenções indicadas", "type": "textarea"},
+        {"key": "duracao_estimada", "label": "Duração estimada", "type": "text", "hint": "Ex: 6 meses, indeterminado"},
+        {"key": "criterios_alta", "label": "Critérios de alta", "type": "textarea"},
+        {"key": "encaminhamentos", "label": "Encaminhamentos paralelos", "type": "textarea", "hint": "Psiquiatria, médico, outras especialidades"}
+    ]'::jsonb,
+    true,
+    true,
+    true
+);
+
+COMMIT;
diff --git a/development/02-auditoria/AUDIT_BASELINE.md b/development/02-auditoria/AUDIT_BASELINE.md
new file mode 100644
index 0000000..f8a0bba
--- /dev/null
+++ b/development/02-auditoria/AUDIT_BASELINE.md
@@ -0,0 +1,302 @@
+# Audit Baseline — 6 Módulos vs Blueprints
+
+> **Data:** 2026-05-20
+> **Método:** 6 agentes Explore em paralelo, cada um auditou 1 módulo contra os 3 blueprints (repository, composable, quick-create overlay)
+> **Saída:** mapa exato do trabalho da Fase 1 da Padronização Sweep
+
+---
+
+## Sumário Executivo
+
+| # | Módulo | Estado | Alta | Média | Baixa | Bloqueador |
+|---|---|---|---|---|---|---|
+| 1 | Home / Components | Parcial | 3 | 2 | 2 | — |
+| 2 | Pacientes | Parcial | 4 | 6 | 2 | — |
+| 3 | Prontuário | **Embrionário** | 3 | 3 | 0 | Schema clínico ausente |
+| 4 | Financeiro | **Órfão** | 6 | 3 | 1 | Overlap com agenda + double-billing risk |
+| 5 | Multi-tenant | Parcial | 2 | 3 | 2 | **Convites/membership inexistem** |
+| 6 | Notificações | **Embrionário** | 5 | 3 | 1 | 3 canais fragmentados, SMS envio só stub |
+
+**Totais:** 23 alta · 20 média · 8 baixa = **51 divergências catalogadas** + 4 gaps estruturais.
+
+---
+
+## Surpresas (descobertas que mudam o plano)
+
+### 🚨 1. Convites/membership de tenant — gap apenas no front (CORRIGIDO 2026-05-20)
+
+Agente Multi-tenant disse: **não existe** repository/composable pra `sendInvite(tenantId, email)`, `acceptInvite(inviteId)`, `listTenantMembers(tenantId)`. **Correção:** a tabela `public.tenant_invites` JÁ EXISTE no schema (`tenants_multi_tenant.sql:100`) com campos completos (id, tenant_id, email, role CHECK ['therapist','secretary'], token, invited_by, expires_at default 7d, accepted_at/by, revoked_at/by). Falta APENAS UI + composables/services no front.
+
+Recomendação: criar `features/tenantship/` com services + composables + página `/admin/members` usando a tabela existente. Sem migration de schema necessária. Reduz escopo de 0.5.D.
+
+### 🚨 2. Lógica de billing duplicada agenda ↔ financeiro — risco de double-billing
+
+`useAgendaFinanceiro.gerarCobrancaManual()` (composables raiz) e `useFinancialRecords.createRecord()` (composables raiz) **chamam a mesma RPC** `create_financial_record_for_session`. Sem coordenação = race condition silenciosa.
+
+`useAgendaFinanceiro.handleStatusChange()` ainda relê `financial_records` direto via `.select('id').eq('agenda_evento_id', ...)` — query que deveria viver só no useFinancialRecords.
+
+Recomendação: consolidar em 1 composable orquestrador, ou separar responsabilidades com coordenação explícita via fila.
+
+### 🚨 3. Quick-create overlay — promotion criteria atingida ANTES da hora
+
+Blueprint documentei como "agenda-only, promover quando aparecer 2º caso de uso". Agente Home descobriu **3 quick-create candidatos JÁ em produção**, fora da agenda:
+
+- `src/components/CadastroRapidoMedico.vue` (supabase direto)
+- `src/components/CadastroRapidoConvenio.vue` (supabase direto)
+- `src/components/ComponentCadastroRapido.vue` (genérico, supabase direto)
+
+São o 2º, 3º e 4º casos. **Promover agora** muda o blueprint de "agenda-only" pra universal, e dá fix em 3 componentes ao mesmo tempo.
+
+### 🚨 4. Prontuário sem schema clínico
+
+Agente Prontuário: o "Prontuário" hoje é shell de abas que reusa `usePatientSessions`. Schema vazio pra anamnese, evolução clínica, plano terapêutico. **Não dá pra padronizar antes de modelar.**
+
+Recomendação: adicionar etapa "modelagem schema clínico" como pré-requisito pro módulo 3 da Fase 1.
+
+### 🟡 5. `error = ref(null)` vs `ref('')` confirmado como divergência sistêmica
+
+Aparece em pacientes, financeiro, alguns lugares de notificações. Confirma a canonicalização do composable blueprint (`''` default). Fix mecânico, fácil de aplicar.
+
+### 🟡 6. Setup Wizard tem 8 queries supabase inline
+
+Já estava no `project_graphify_findings_20260504` ("Setup Wizard cohesion 0.05"). Agora quantificado: 8 queries (linhas 419, 429, 446, 595, 626, 656, 681, 706). Fix: criar `setupRepository.js` + `useSetupWizard.js`.
+
+---
+
+## Cross-cutting patterns (não específicos a 1 módulo)
+
+| Pattern | Onde aparece | Severidade | Fix |
+|---|---|---|---|
+| `error = ref(null)` | Pacientes, Financeiro, partes de Notificações | Média | Mecânico: `ref('')` |
+| `supabase.from(...)` em composable | Pacientes (4 composables), Financeiro (2), Notificações (3+), Multi-tenant (1) | Alta | Extrair pra repository |
+| SELECT inline em vez de constante | Pacientes (3), Financeiro, Notificações | Média | Extrair pra `<feature>Selects.js` |
+| UPDATE/DELETE sem `.eq('tenant_id', tid)` | Pacientes (2), Financeiro (3) | Alta | Defesa em profundidade |
+| `getUid()` / `useTenantStore()` duplicados | Múltiplos composables | Baixa | Helper compartilhado |
+| State em variável módulo (vaza entre instâncias) | `usePatientFinancial._lastPatientId` | Alta | Mover DENTRO da `function use*()` |
+| `_tenantGuards.js` ausente em todo módulo não-agenda | Todos | Média | Replicar pattern |
+
+---
+
+## Detalhamento por Módulo
+
+### 1. Home / Components base
+
+**Estado:** Parcial. Falta camada de repository. 3 quick-creates espalhados fazem supabase direto.
+
+**Arquivos-chave:**
+- `src/views/pages/HomeCards.vue` — roteador de perfis + RPC de auditoria interna
+- `src/layout/melissa/MelissaLayout.vue` — orquestrador (~90 imports, monolítico)
+- `src/components/CadastroRapidoMedico.vue` — quick-create supabase direto
+- `src/components/CadastroRapidoConvenio.vue` — quick-create supabase direto
+- `src/components/ComponentCadastroRapido.vue` — quick-create genérico supabase direto
+
+**Divergências:**
+
+| Sev | Tipo | Local | Problema | Fix |
+|---|---|---|---|---|
+| ~~Alta~~ ✅ | quick-create | `CadastroRapidoMedico.vue:150` | ~~`supabase.from()` direto sem repository~~ | **RESOLVIDO 2026-05-20 (M1.1):** `features/medicos/services/medicosRepository.js` criado + componente refatorado pra usar `useMedicos` composable |
+| ~~Alta~~ ✅ | quick-create | `CadastroRapidoConvenio.vue:98` | ~~`supabase.from()` inline~~ | **RESOLVIDO 2026-05-20 (M1.2):** `features/insurance/services/insurancePlansRepository.js` criado + componente usa `useInsurancePlans` composable. Bônus: agenda `InsurancePlanQuickCreateDialog.vue` também migrado. |
+| ~~Alta~~ ✅ | quick-create | `ComponentCadastroRapido.vue:263` | ~~`insert()` sem validação `tenant_id`+`owner_id`~~ | **RESOLVIDO 2026-05-20 (M1.3):** componente usa `usePatients.create()`; tenant resolvido via `getMyActiveMember()` (helper novo em tenantship); repository injeta `owner_id = auth.uid()` sempre, ignora payload. |
+| ~~Média~~ ✅ | composable | `CadastroRapidoMedico.vue:49-58` | ~~`getTenantId()` via fallback query em vez de store~~ | **RESOLVIDO 2026-05-20 (M1.1):** removido — repository usa `resolveTenantId()` canônico |
+| ~~Média~~ ✅ | composable | `CadastroRapidoConvenio.vue:94-100` | ~~`loadPlans()` sem `.eq('tenant_id', tid)`~~ | **RESOLVIDO 2026-05-20 (M1.2):** repository agora filtra por tenant_id + owner_id |
+| ~~Baixa~~ ✅ | outro | `HomeCards.vue:23-33` | ~~`TEST_ACCOUNTS` hardcoded~~ | **RESOLVIDO 2026-05-20 (M1.4):** extraído pra `src/config/devTestAccounts.js` |
+| Baixa | outro | `MelissaLayout.vue:1-150` | 90+ imports, monolítico | Refactor Fase 2 (M1.6 — sessão dedicada) |
+
+### 2. Pacientes
+
+**Estado:** Parcial. `patientsRepository` é o ÚNICO repo padronizado fora da agenda (8/10 conformidade). Composables têm violações de camada.
+
+**Arquivos-chave:**
+- `src/features/patients/services/patientsRepository.js` — referência parcial
+- `src/features/patients/composables/usePatients.js` — thin wrapper (falha em error type)
+- `src/features/patients/composables/usePatientDetail.js` — supabase direto
+- `src/features/patients/composables/usePatientFinancial.js` — supabase direto + estado módulo
+- `src/features/patients/composables/usePatientSessions.js` — supabase direto
+- `src/components/ui/PatientCreatePopover.vue` — padrão OK (não é quick-create overlay)
+
+**Divergências:**
+
+| Sev | Tipo | Local | Problema | Fix |
+|---|---|---|---|---|
+| ~~Alta~~ ✅ | repo | `patientsRepository.js:64` | ~~`createPatient` aceita `owner_id` do payload~~ | **RESOLVIDO 2026-05-20 (spillover M1.3):** repository sempre injeta `owner_id = await getUid()`; strip `owner_id` do payload via destructure. |
+| ~~Alta~~ ✅ | composable | `usePatientDetail.js:13-40` | ~~supabase direto em 4 funções~~ | **RESOLVIDO 2026-05-20 (M2.2):** 4 funções migradas pra patientsRepository |
+| ~~Alta~~ ✅ | composable | `usePatientFinancial.js:21,156-164` | ~~`_lastPatientId` em variável módulo + supabase direto~~ | **RESOLVIDO 2026-05-20 (M2.3):** state movido DENTRO da function; mutations via repository |
+| ~~Alta~~ ✅ | composable | `usePatientSessions.js:33-44, 127-182` | ~~supabase direto em 2 mutations~~ | **RESOLVIDO 2026-05-20 (M2.4):** list+create+updateStatus via repository (com helper findSessionByRecurrence pra materialização) |
+| ~~Média~~ ✅ | composable | `usePatients.js:22` | ~~`error = ref(null)` viola canon~~ | **RESOLVIDO 2026-05-20 (spillover M1.3):** `error = ref('')` canon do composable-blueprint. |
+| ~~Média~~ ✅ | composable | `usePatientDetail.js:69` | ~~Funções internas retornam `null` silencioso em erro~~ | **RESOLVIDO 2026-05-20 (M2.2):** repository functions throw em vez de return null |
+| Média | composable | `usePatientFinancial.js:149-191, usePatientSessions.js:140-182` | Mutations retornam `{ok, data?, error?}` em vez de throw | Padrão preservado por compat com callers; fix posterior em sessão dedicada |
+| ~~Média~~ ✅ | composable | `usePatientRecurrences.js:34` | ~~`.select('*')` inline~~ | **RESOLVIDO 2026-05-20 (M2.1):** `PATIENT_RECURRENCE_RULES_SELECT` em patientsSelects.js |
+| ~~Média~~ ✅ | composable | `usePatientMessages.js:29, usePatientDocuments.js:30, usePatientSessions.js:38` | ~~SELECT inline sem constante~~ | **RESOLVIDO 2026-05-20 (M2.1):** 5 constantes em patientsSelects.js |
+| ~~Média~~ ✅ | composable | `usePatientFinancial.js:127-130, usePatientSessions.js:211-274` | ~~Mutações sem `.eq('tenant_id', tid)`~~ | **RESOLVIDO 2026-05-20 (M2.3+M2.4):** todas mutations no repository usam `.eq('tenant_id', tid)` |
+| ~~Baixa~~ ✅ | composable | `usePatients.js:45` | ~~`remove` não re-throw~~ | **RESOLVIDO 2026-05-20 (M2.6):** Tipo A canônico completo |
+| Baixa | composable | `usePatientSessions.js:67` | Filtro de virtual occurrences encapsulado no composable | Documentar como legado pré-refactor |
+
+### 3. Prontuário/Evolução
+
+**Estado:** **Embrionário.** Mal-existe. Aba "Prontuário evolutivo" é placeholder vazio.
+
+**Arquivos-chave:**
+- `src/features/patients/prontuario/PatientProntuario.vue` (188 KB) — shell de abas
+- `src/features/patients/prontuario/PatientConversationsTab.vue` (11.8 KB) — timeline supabase direto
+- `usePatientSessions.js` reusado (não é prontuário-específico)
+
+**Divergências:**
+
+| Sev | Tipo | Local | Problema | Fix |
+|---|---|---|---|---|
+| Alta | composable | `PatientProntuario.vue:29` | supabase direto pra `conversation_messages`, `agenda_eventos`, `financial_records`, `documents`, `patient_groups`, `patient_tags` | Extrair `usePatientConversations`, `usePatientFinancial`, `usePatientDocuments` |
+| Alta | repo | (não existe) | Nenhum repository pras tabelas do prontuário | Criar `patientFinancialRepository.js`, `patientDocumentsRepository.js` |
+| Alta | composable | `PatientConversationsTab.vue:8` | Query direto a `conversation_messages` | Mover pra repository |
+| Média | gap | `PatientProntuario.vue:1950` | Aba "Prontuário" é placeholder vazio — schema clínico não modelado | **Decidir modelo: `patient_notes`? `clinic_sessions`? `patient_clinical_notes`?** |
+| Média | composable | `usePatientSessions.js:38` | Queries inline a `agenda_eventos`, `recurrence` | Mover pra `patientSessionsRepository.js` |
+| Média | repo | `PatientProntuario.vue:381-384` | `updateSessionStatus` mutação inline em componente | Mover pra repository |
+
+**Gaps estruturais:**
+1. Repository layer ausente (3 repositories a criar)
+2. Composable layer incompleto (3 composables a criar)
+3. **Schema clínico inexistente** — anamnese, evolução, plano terapêutico não modelados
+4. PatientProntuario.vue é monolítico (188 KB) — refactor candidate
+
+### 4. Financeiro
+
+**Estado:** **Órfão.** Módulo existe mas sem camada repository; composables raiz fazem supabase direto.
+
+**Arquivos-chave:**
+- `src/features/financeiro/pages/FinanceiroPage.vue` — supabase direto inline
+- `src/features/financeiro/pages/FinanceiroDashboardPage.vue` — RPC direto inline
+- `src/composables/useFinancialRecords.js` — composable raiz com supabase inline (sem repository)
+- `src/composables/useAgendaFinanceiro.js` — orquestrador agenda-financeiro com lógica duplicada
+
+**Divergências:**
+
+| Sev | Tipo | Local | Problema | Fix |
+|---|---|---|---|---|
+| Alta | repo | `useFinancialRecords.js:294` | UPDATE sem `.eq('tenant_id', tid)` | Defesa em profundidade |
+| Alta | repo | `useAgendaFinanceiro.js:194, 215` | UPDATE sem `.eq('tenant_id', tid)` em 2 pontos | Idem |
+| Alta | composable | `useFinancialRecords.js:58` | `error = ref(null)` | `ref('')` |
+| Alta | camada | `useFinancialRecords.js` (todo) | supabase direto viola blueprint | Extrair pra `financeiro/services/financialRecordsRepository.js` |
+| Alta | camada | `useAgendaFinanceiro.js:191, 205, 209` | supabase direto | Mover pra repository ou RPC wrapper |
+| Alta | overlap | `useAgendaFinanceiro.js:114-151` + `useFinancialRecords.js:157-189` | **Lógica duplicada de criação de cobrança** — ambos chamam mesma RPC | Consolidar em 1 composable orquestrador |
+| Média | convenção | `FinanceiroPage.vue:22-51` | supabase direto em componente | Mover pra composable |
+| Média | convenção | `FinanceiroDashboardPage.vue:68, 78, 144` | RPC inline em componente | Criar `useFinancialDashboard` |
+| Média | SELECT | `useFinancialRecords.js:40-51` | BASE_SELECT constante OK, mas sem `flatten<Feature>Row` | Adicionar helper se joins aninhados |
+| Baixa | cosmético | `FinanceiroPage.vue:27-40` | Formatadores BRL/Date duplicados na dashboard | Extrair pra `financeiro/utils/formatters.js` |
+
+**Overlap crítico com agenda:**
+- `useAgendaFinanceiro.gerarCobrancaManual()` vs `useFinancialRecords.createRecord()` chamam mesma RPC — **risco double-billing em race condition**
+- `useAgendaFinanceiro.handleStatusChange()` relê `financial_records` (linhas 191, 205) — query que pertence a `useFinancialRecords`
+- Ambos importam `useTenantStore` + `getUid()` inline (duplicação)
+
+### 5. Multi-tenant
+
+**Estado:** Parcial. Stores OK. **Gap crítico: convites/membership inexistem.** SetupWizard e SaasTenantFeaturesPage com queries inline.
+
+**Arquivos-chave:**
+- `src/stores/tenantStore.js` — Pinia store + memberships read-only via RPC
+- `src/stores/tenantFeaturesStore.js` — computed store + TTL cache + RPC
+- `src/stores/entitlementsStore.js` — view-based (`v_tenant_entitlements`, `v_user_entitlements`)
+- `src/features/setup/SetupWizardPage.vue` — 8 queries supabase inline
+- `src/views/pages/saas/SaasTenantFeaturesPage.vue` — 4 queries inline
+- `src/features/clinic/components/ModuleRow.vue` — dumb component OK
+
+**Divergências:**
+
+| Sev | Tipo | Local | Problema | Fix |
+|---|---|---|---|---|
+| ~~Alta~~ ✅ | composable | `SaasTenantFeaturesPage.vue:124-129` | ~~4 queries supabase direto~~ | **RESOLVIDO 2026-05-20 (M5 quick win):** extraído pra `src/services/tenantFeatureAdminService.js`. |
+| Alta | repository | `SetupWizardPage.vue:419, 429, 446, 595, 626, 656, 681, 706` | 8 supabase queries inline em página | Criar `setupRepository.js` + `useSetupWizard.js` |
+| Média | store | `tenantFeaturesStore.js:134` | `fetchForTenant` faz `from('tenant_features')` direto | Wrapper em `tenantFeaturesRepository.js` |
+| Média | store | `entitlementsStore.js:136, 177` | Queries em views direto | Aceitar como read-only com comentário |
+| Média | convention | `SaasTenantFeaturesPage.vue:33-53` | Error pattern inconsistente | Usar toast |
+| Baixa | naming | `tenantFeaturesStore.js:52` | `loadedForTenantId` vs `tenantId` ambíguo | Renomear |
+| Baixa | cosmetic | `SetupWizardPage.vue:60` | `isClinicRole` via string matching | Usar `useRoleGuard` |
+
+**Gap crítico — convites/membership:**
+
+Grep por `tenant_members`, `tenant_invite`, `convite`, `invitation` retornou **zero** em `features/`. Não existe:
+- Repository para `sendInvite(tenantId, email)`
+- Repository para `acceptInvite(inviteId)`
+- Repository para `listTenantMembers(tenantId)`
+- Composable wrapper
+- Página `/admin/members` pra gestão
+
+**Recomendação:** criar `features/tenantship/` (ou `features/team/`) completo. Bloqueador de MVP.
+
+### 6. Notificações
+
+**Estado:** **Embrionário.** Fragmentado em 3+ canais (WhatsApp Evolution, WhatsApp Twilio, SMS Twilio, in-app, notices globais), sem padronização.
+
+**Arquivos-chave:**
+- `src/features/notices/noticeService.js` — supabase direto sem repository
+- `src/features/conversations/CRMConversasPage.vue` — página complexa, lógica não extraída
+- `src/composables/useConversations.js` — query + business logic + supabase direto
+- `src/composables/useNotifications.js` — toast + realtime + polling
+- `src/stores/notificationStore.js` — in-app puro (OK)
+- `src/stores/conversationDrawerStore.js` — mistura send WhatsApp/SMS + templates
+- `src/stores/twilioWhatsappStore.js` — estado Twilio subcontas
+- `src/views/pages/notifications/SmsChannelSetupPage.vue` — credenciais via supabase
+- `src/views/pages/therapist/NotificationsHistoryPage.vue` — sync com store
+
+**Divergências:**
+
+| Sev | Tipo | Local | Problema | Fix |
+|---|---|---|---|---|
+| Alta | repo | `noticeService.js:28-44` | SELECT inline | Criar `notices/noticeSelects.js` |
+| Alta | composable | `useConversations.js:85-91` | supabase direto, sem repository | Criar `conversations/services/conversationsRepository.js` |
+| Alta | repo | `useConversations.js:229-244` | SELECT inline em `loadThreadMessages()` | Extrair pra repository |
+| Alta | gap | `conversationDrawerStore.js:339-346` | Edge function invoke direto sem fallback/retry | Criar `sendMessageService.js` com error handling |
+| Alta | canais | `conversationDrawerStore.js:327-377` | Lógica de envio WhatsApp (Evolution + Twilio) sem abstração | Factory por canal |
+| Média | error | `useNotifications.js:117-145` | Realtime/polling sem try/catch | Wrap |
+| Média | repo | `conversationDrawerStore.js:414-449` | `loadTemplates()` sem `.eq('tenant_id', ...)` no 2º select | Adicionar guard |
+| Média | naming | `SmsChannelSetupPage.vue:84-102` | Query sem SELECT canônico | Extrair |
+| Baixa | cosmético | `useConversations.js:165-184` | Channel filter hardcoded ['whatsapp','sms','email'] | Exportar `CHANNEL_TYPES` const |
+
+**Canais identificados:**
+1. WhatsApp (Evolution API) — Parcial
+2. WhatsApp (Twilio) — Parcial
+3. SMS (Twilio) — **Stub** (só setup, sem envio)
+4. In-app (browser notifications) — Funcional
+5. Global Notices — Funcional
+
+**Gaps estruturais:**
+- Repositórios inexistem (conversas, mensagens, canais)
+- `_tenantGuards.js` ausente
+- SELECT canônico fragmentado
+- Composables fat (`useConversations` faz 3 coisas)
+- SMS envio não implementado (só credenciais)
+
+---
+
+## Próximos passos
+
+### Ajustes ao plano original
+
+**Fase 0** — concluída. Audit baseline pronto.
+
+**Fase 1** — sequenciamento revisado considerando as 4 surpresas:
+
+| Ordem | Módulo | Pré-requisito | Observação |
+|---|---|---|---|
+| 1 | **Home/Components** | — | Inclui promover quick-create blueprint (3 candidates já existem) + criar `medicos/` e `insurance/` features |
+| 1.5 | **Quick-create blueprint promotion** | — | Mover blueprint de "agenda-only" pra universal; refatorar 3 CadastroRapido components em paralelo |
+| 2 | **Pacientes** | — | `patientsRepository` já parcial; fix 4 composables com supabase direto |
+| 3 | **Prontuário (parcial)** | **Decisão de schema clínico** | Sem schema, só dá pra criar repositories pras tabelas existentes (financial_records, documents) |
+| 4 | **Financeiro** | Decisão sobre overlap com agenda | Resolver double-billing risk ANTES de refactor |
+| 5 | **Multi-tenant + Convites** | — | Criar `tenantship/` feature inteiro (gap crítico) |
+| 6 | **Notificações** | — | Pesado: 3 canais, abstração por factory |
+
+### Decisões pendentes (precisa de você)
+
+1. **Quick-create blueprint:** promover pra universal agora ou manter agenda-only? (recomendo promover — promotion criteria atingida)
+2. **Schema clínico do prontuário:** modelar agora (bloqueador) ou empurrar pra Fase 1 estendida?
+3. **Overlap billing agenda↔financeiro:** consolidar em 1 composable OU separar com coordenação via fila? (recomendo consolidar)
+4. **Convites/membership:** criar feature `tenantship/` separada OU absorver em `clinic/`? (recomendo separada — semântica diferente)
+5. **`dev_auditoria_items` no banco:** popular agora os 51 itens via SQL OU UI uma a uma? (recomendo SQL batch insert — mais rápido pra começar Fase 1)
+
+---
+
+## Referências
+
+- Blueprints: `blueprints/repository-blueprint.md`, `composable-blueprint.md`, `quick-create-overlay-blueprint.md`
+- Estratégia: `development/02-auditoria/PADRONIZACAO.md`
+- Memória: `project_padronizacao_sweep.md`, `project_graphify_findings_20260504.md`
diff --git a/development/02-auditoria/DESIGN_BILLING_ORCHESTRATOR.md b/development/02-auditoria/DESIGN_BILLING_ORCHESTRATOR.md
new file mode 100644
index 0000000..88833d9
--- /dev/null
+++ b/development/02-auditoria/DESIGN_BILLING_ORCHESTRATOR.md
@@ -0,0 +1,480 @@
+# Design — useBillingOrchestrator
+
+> **Data:** 2026-05-20
+> **Tipo:** Design doc (sem código). Implementação fica pra Módulo 4 (Financeiro) da Fase 1.
+> **Resolve:** decisão 7 do PADRONIZACAO.md — overlap billing agenda ↔ financeiro com risco de double-billing.
+
+---
+
+## 1. Problema atual
+
+### 1.1 Três caminhos pra criar cobrança
+
+Cobrança de sessão hoje pode ser criada por **3 lugares diferentes**:
+
+| # | Caminho | Arquivo | Quando |
+|---|---|---|---|
+| A | Botão "Gerar cobrança" manual | `useAgendaFinanceiro.gerarCobrancaManual()` (linha 114) | User clica explicitamente em sessão sem cobrança |
+| B | Mudança de status na agenda | `useAgendaFinanceiro.handleStatusChange()` (linha 163) | User troca status (agendado→faltou, etc) |
+| C | Decisões aplicadas no Melissa | `useMelissaAgenda._applyStatusDecisions()` (linha 1450) | User confirma transição de status no fluxo Melissa |
+
+**Os 3 chamam a mesma RPC** `create_financial_record_for_session`. Sem coordenação central. Resultado: race condition silenciosa possível.
+
+### 1.2 UPDATEs diretos espalhados
+
+`handleStatusChange` também faz UPDATE/SELECT em `financial_records` direto (linhas 191, 194, 205, 208) — queries que **pertencem ao useFinancialRecords** mas são duplicadas aqui pra evitar import circular.
+
+### 1.3 State em variável de módulo (vaza)
+
+`useAgendaFinanceiro.js:38`:
+```js
+const _exceptionsCache = new Map();  // ← módulo-level, vaza entre instâncias
+```
+
+Quando user troca de tenant, cache não invalida automaticamente. Memória `useAgendaFinanceiro.invalidateExceptionsCache()` precisa ser chamada manualmente em vários lugares.
+
+### 1.4 Cenários de double-billing concretos
+
+1. **Race manual + status:** user clica "Gerar cobrança" + muda status pra "faltou" em < 200ms. Path A insere registro pending; Path B detecta sessão sem `billed` (já que ainda não chegou) e cria outro registro pela exceção.
+2. **Realizado vindo de faltou paid:** sessão estava `faltou` com multa paid. User volta pra `agendado` → `realizado`. Path B/C podem regerar cobrança em cima da multa paid existente (memória `project_rpc_idempotency_cancelled` foi um fix relacionado mas não cobre todo o problema).
+3. **Pacote saldo + adicional:** sessão de pacote `billing_contract_id` setado bloqueia Path A (linha 116). Mas Path B/C podem **não checar** esse campo em alguma branch — risco de cobrança individual em sessão de pacote.
+
+---
+
+## 2. Goals & Non-goals
+
+### Goals
+1. **Single entry point** pra qualquer mudança de billing relacionada a evento da agenda.
+2. **Idempotência garantida** — chamar 2× a mesma intenção produz o mesmo resultado.
+3. **State machine explícito** de transições de status com consequências financeiras claras.
+4. **Reverse transitions** tratadas (realizado→agendado, faltou→agendado, cancelado→agendado).
+5. **Orchestrador NUNCA toca supabase direto** — só via repository e composable de financeiro.
+6. **Cache de regras de exceção** vive na instância do composable, não em módulo.
+
+### Non-goals (fora deste escopo)
+1. Implementação — só design. Código vem na Fase 1 Módulo 4.
+2. Refator de `useFinancialRecords` em si (extrair pra repository) — vai junto no Módulo 4.
+3. Gateway de pagamento (Asaas) — Fase 3 do ROADMAP.
+4. Repasse a terapeutas — `therapist_payouts` separado.
+5. UI/UX de confirmação de reverse transitions — já mapeado em memória `project_agenda_reverse_transitions`, implementação no Módulo 4.
+
+---
+
+## 3. State machine de transições
+
+### 3.1 Status válidos
+
+Enum `status_evento_agenda` (do schema): `agendado | realizado | faltou | cancelado | remarcar`
+
+### 3.2 Matriz `from → to`
+
+|  | →agendado | →realizado | →faltou | →cancelado | →remarcar |
+|---|---|---|---|---|---|
+| **agendado→** | — | ✅ FORWARD | ✅ FORWARD | ✅ FORWARD | ✅ FORWARD |
+| **realizado→** | ⚠️ REVERSE | — | ⚠️ REVERSE | ⚠️ REVERSE | ❌ inválida |
+| **faltou→** | ⚠️ REVERSE | ⚠️ CROSS | — | ⚠️ CROSS | ❌ inválida |
+| **cancelado→** | ⚠️ REVERSE | ⚠️ CROSS | ⚠️ CROSS | — | ❌ inválida |
+| **remarcar→** | ✅ FORWARD | ✅ FORWARD | ✅ FORWARD | ✅ FORWARD | — |
+
+### 3.3 Tabela de consequências financeiras
+
+| Transição | Ação financeira default | Decisão do user (override) |
+|---|---|---|
+| `agendado→realizado` | Criar pending (se ainda não billed) com `amount = event.price` | Marcar como já recebido (forma de pagamento) |
+| `agendado→faltou` | Consultar `financial_exceptions[patient_no_show]` → criar multa OR cancelar existente | Consumir saldo de pacote (se aplicável) |
+| `agendado→cancelado` | Consultar `financial_exceptions[patient_cancellation]` + `min_hours_notice` → criar taxa de cancelamento tardio OR cancelar existente | — |
+| `realizado→agendado` | **REVERSE:** se record `paid` existe → confirm dialog (refund_paid). Se `pending` → soft-cancel. Se `paid+package`: refund + devolver saldo | Reverter manualmente sem auto |
+| `realizado→faltou` | **CROSS:** reverter realizado + aplicar regra de no-show. Se já paid → manter pago e converter em multa | — |
+| `faltou→agendado` | **REVERSE:** cancelar multa pending. Se multa paid → confirm dialog (refund) | — |
+| `cancelado→agendado` | **REVERSE:** cancelar taxa de cancelamento (se houver) | — |
+| `*→remarcar` | Manter cobrança existente, atualizar `due_date` quando reagendar | — |
+
+### 3.4 Pacote (billing_contract_id presente)
+
+**Sobre qualquer transição:** se `event.billing_contract_id` não-nulo, **não criar nem cancelar `financial_records` individual**. Em vez disso:
+- `agendado→realizado`: incrementa `billing_contracts.sessions_used`
+- `agendado→faltou` ou `agendado→cancelado` com `default_consume_on_miss=true`: incrementa `sessions_used`
+- `realizado→agendado`: decrementa `sessions_used` (refresh FRESH do DB antes, memória `project_agenda_reverse_transitions`)
+
+Memória relevante: `project_cross_week_propagation` — bulk-load tem que rodar mesmo sem reais na view + query records cross-week por recurrence_id.
+
+---
+
+## 4. API shape
+
+### 4.1 Signature do composable
+
+```js
+export function useBillingOrchestrator() {
+    // ─── State ──────────────────────────────────────────────────
+    const loading = ref(false);     // operação async em andamento
+    const error = ref('');          // string vazia default (canon do composable-blueprint)
+
+    // ─── Public actions ─────────────────────────────────────────
+
+    /**
+     * Orquestra mudança de status de um evento + consequências financeiras.
+     * Single entry point — substitui os 3 caminhos atuais.
+     *
+     * @param {Object} params
+     * @param {Object} params.event              - row de agenda_eventos completa
+     * @param {string} params.fromStatus
+     * @param {string} params.toStatus
+     * @param {Object} [params.decisions]        - overrides do user (ver decisões pendentes seção 5)
+     * @returns {Promise<{ok, actions: Array<BillingAction>, error?}>}
+     */
+    async function applyStatusChange(params) { ... }
+
+    /**
+     * Gera cobrança manual pra evento sem cobrança ainda. Idempotente.
+     * Bloqueia se billing_contract_id presente.
+     */
+    async function generateChargeForEvent(event, options = {}) { ... }
+
+    /**
+     * Lista records financeiros vinculados ao evento.
+     */
+    async function fetchRecordsForEvent(eventId) { ... }
+
+    /**
+     * Cancela TODOS os records pending/overdue de um evento (soft).
+     * Use APENAS em reverse transitions confirmadas pelo user.
+     */
+    async function cancelRecordsForEvent(eventId, reason) { ... }
+
+    /**
+     * Lê regra de exceção financeira com cache local (instância).
+     */
+    async function getExceptionRule(tenantId, exceptionType) { ... }
+
+    function invalidateRules() { ... }  // chama em troca de tenant
+
+    return {
+        loading, error,
+        applyStatusChange, generateChargeForEvent,
+        fetchRecordsForEvent, cancelRecordsForEvent,
+        getExceptionRule, invalidateRules
+    };
+}
+```
+
+### 4.2 Tipos relevantes
+
+```js
+/** @typedef {Object} BillingAction
+ *  Resultado de uma operação. Compõe o array `actions` retornado por applyStatusChange.
+ * @property {string} type           - 'created' | 'updated' | 'cancelled' | 'paid' | 'package_consumed' | 'package_returned' | 'noop'
+ * @property {string} [recordId]
+ * @property {number} [amount]
+ * @property {string} [reason]
+ */
+
+/** @typedef {Object} BillingDecisions
+ *  Overrides explícitos do user. Quando ausente, orchestrator decide via regras.
+ * @property {boolean} [consumePackageSession]    - faltou/cancelado: consumir saldo de pacote
+ * @property {'auto'|'always'|'never'} [applyNoShowFee]  - aplicar multa em faltou
+ * @property {'cancel_pending'|'refund_paid'|'manual'} [reverseCleanup]  - reverse: como tratar records existentes
+ */
+```
+
+### 4.3 Exemplo de uso (caller)
+
+```js
+// Em AgendaEventDialog.vue (ou onde quer que aplique status change)
+import { useBillingOrchestrator } from '@/features/financeiro/composables/useBillingOrchestrator';
+
+const billing = useBillingOrchestrator();
+
+async function onStatusChange(novoStatus, decisoes) {
+    const result = await billing.applyStatusChange({
+        event: eventoAtual.value,
+        fromStatus: eventoAtual.value.status,
+        toStatus: novoStatus,
+        decisions: decisoes  // pode ser undefined — orchestrator usa regras default
+    });
+
+    if (!result.ok) {
+        toast.add({ severity: 'error', summary: 'Falha', detail: result.error });
+        return;
+    }
+
+    // result.actions é narrativa do que aconteceu — use pra UI feedback
+    for (const action of result.actions) {
+        if (action.type === 'created') showCreatedToast(action.amount);
+        else if (action.type === 'cancelled') showCancelledToast();
+        // ...
+    }
+}
+```
+
+---
+
+## 5. Arquitetura interna
+
+### 5.1 Dependências (camadas)
+
+```
+useBillingOrchestrator
+        │
+        ├──> useFinancialRecords (thin wrapper)
+        │       │
+        │       └──> financialRecordsRepository
+        │               │
+        │               └──> supabase (RPC + tabela)
+        │
+        ├──> useBillingContracts (composable a criar — pacotes)
+        │       │
+        │       └──> billingContractsRepository
+        │
+        ├──> useFinancialExceptions (composable — regras de exceção)
+        │       │
+        │       └──> financialExceptionsRepository
+        │
+        └──> useAgendaEvents (THIN — só pra propagação reativa, não pra writes)
+                │
+                └──> agendaRepository (já existe)
+```
+
+**Regra absoluta:** orchestrator não importa `supabase` diretamente. Só dos composables/repositories acima.
+
+### 5.2 Internals
+
+```js
+// PRIVATE — não exportado
+const _rulesCache = new Map();  // ← agora DENTRO da function, vive com a instância
+
+async function _resolveBillingState(eventId) {
+    // Snapshot completo: records[], contract?, exceptionRule?
+    // Pra decidir transição sem race conditions.
+    const records = await financialRecords.fetchByEvent(eventId);
+    const packageInfo = event.billing_contract_id
+        ? await billingContracts.fetch(event.billing_contract_id)
+        : null;
+    return { records, packageInfo };
+}
+
+async function _runTransition(event, fromStatus, toStatus, decisions, state) {
+    const key = `${fromStatus}→${toStatus}`;
+    const handler = TRANSITION_HANDLERS[key];
+    if (!handler) {
+        throw new Error(`Transição inválida: ${key}`);
+    }
+    return handler({ event, decisions, state });
+}
+
+const TRANSITION_HANDLERS = {
+    'agendado→realizado': _handleRealizado,
+    'agendado→faltou': _handleFaltou,
+    // ... 1 handler por transição válida
+};
+
+async function _handleRealizado({ event, decisions, state }) {
+    if (event.billing_contract_id) {
+        return _consumePackageSession(event);
+    }
+
+    // Sessão avulsa — criar pending se não tem record ativo
+    const hasActive = state.records.some(r => ['pending','overdue','paid'].includes(r.status));
+    if (hasActive) {
+        return [{ type: 'noop', reason: 'Record já existe' }];
+    }
+    const record = await financialRecords.create({
+        patient_id: event.patient_id,
+        agenda_evento_id: event.id,
+        amount: event.price,
+        due_date: _eventDateISO(event)
+    });
+    return [{ type: 'created', recordId: record.id, amount: event.price }];
+}
+
+async function _handleFaltou({ event, decisions, state }) {
+    if (event.billing_contract_id) {
+        return decisions?.consumePackageSession ?? state.exceptionRule?.default_consume_on_miss
+            ? _consumePackageSession(event)
+            : [{ type: 'noop' }];
+    }
+
+    const rule = await getExceptionRule(event.tenant_id, 'patient_no_show');
+    if (!rule || rule.charge_mode === 'none') {
+        return _cancelExistingPending(state.records);
+    }
+    // ... lógica completa
+}
+```
+
+### 5.3 Idempotência — como o orchestrator garante
+
+Antes de criar record:
+```js
+// 1. Snapshot da state ANTES da decisão (já feito em _resolveBillingState)
+// 2. Verificar se record ativo já existe pro evento+intenção
+const existingActive = state.records.find(r =>
+    ['pending', 'overdue', 'paid'].includes(r.status)
+);
+if (existingActive) {
+    // Decidir: noop, update, ou criar segundo (raro — multa em cima de sessão paid)
+}
+
+// 3. Locks otimistas via UPDATE com .eq('status', expectedStatus)
+//    Se conflito, refresh + re-decide
+```
+
+Antes de update/cancel:
+```js
+// Sempre filtra .eq('tenant_id', tid) defesa em profundidade
+// (corrige divergências do audit baseline)
+```
+
+Para mudanças de pacote:
+```js
+// REFRESH FRESH do banco antes do UPDATE (memória project_agenda_reverse_transitions)
+const currentContract = await billingContracts.fetch(id);
+await billingContracts.update(id, {
+    sessions_used: currentContract.sessions_used - 1
+});
+```
+
+### 5.4 RPC `create_financial_record_for_session` — usar como single insert path
+
+A RPC já existe e tem idempotência (memória `project_rpc_idempotency_cancelled` foi fix recente). Orchestrator usa ela como **única forma de criar record de sessão**. INSERT direto fica APENAS pra `createManualRecord` (lançamento avulso sem evento), que continua em `useFinancialRecords.createManualRecord`.
+
+---
+
+## 6. Plano de migração (faseado, Módulo 4)
+
+### Fase A — Foundation (preparar terreno)
+1. Criar `features/financeiro/services/` com:
+   - `_tenantGuards.js` (copy do agenda)
+   - `financialSelects.js` (extrair `BASE_SELECT` atual)
+   - `financialRecordsRepository.js` (extrair queries do `useFinancialRecords`)
+   - `financialExceptionsRepository.js` (novo — pra `financial_exceptions`)
+   - `billingContractsRepository.js` (novo — pra `billing_contracts`)
+2. Adicionar `.eq('tenant_id', tid)` em todas operações (fix do audit alta sev).
+
+### Fase B — Composables refatorados (sem mudar callers)
+1. Mover `useFinancialRecords.js` pra `features/financeiro/composables/`.
+2. Refatorar pra usar repository (thin wrapper). Aplicar canon `error = ref('')`.
+3. Criar `features/financeiro/composables/useFinancialExceptions.js`.
+4. Criar `features/financeiro/composables/useBillingContracts.js`.
+5. Criar `features/financeiro/composables/useBillingOrchestrator.js` com signature acima.
+6. Callers ainda usam `useFinancialRecords` direto + `useAgendaFinanceiro` — **nada quebra ainda**.
+
+### Fase C — Migração de callers (1 por vez)
+1. Migrar `AgendaEventDialog.vue` pra `useBillingOrchestrator.applyStatusChange` em vez de `useAgendaFinanceiro.handleStatusChange`.
+2. Migrar `useMelissaAgenda._applyStatusDecisions` (linha 1450-1505) pra orchestrator.
+3. Migrar todos os callers de `useAgendaFinanceiro.gerarCobrancaManual` → `useBillingOrchestrator.generateChargeForEvent`.
+
+### Fase D — Cleanup
+1. Deletar `src/composables/useAgendaFinanceiro.js` (callers todos migrados).
+2. Deletar `src/composables/useFinancialRecords.js` raiz (versão refatorada vive em `features/financeiro/composables/`).
+3. Remover `_exceptionsCache` módulo-level (já estava no novo composable).
+
+### Sanity checks pós-migração
+- E2E Playwright: criar sessão → realizar com pagamento → mudar pra faltou → confirmar reverse → verificar contract.sessions_used. **NUNCA double-billing.**
+- Memory `project_agenda_billing_decisoes` — confirmar 5 decisões mantidas (#1 híbrido, #4 semi-auto no-show, #5 bloqueia edit cobrada, #7 credit note, #8 pagamento separado).
+
+---
+
+## 7. Decisões resolvidas (2026-05-20)
+
+### 7.1 ✅ `applyStatusChange` faz APENAS financeiro
+
+Signature final: `applyStatusChange({ event, fromStatus, toStatus, decisions })` retorna `{ ok, actions[], needsConfirmation?, error? }`. Caller é responsável por atualizar a agenda separadamente (`agendaRepository.update()`).
+
+**Consequência:** orchestrator stateless quanto à agenda. Caller faz wrapping:
+```js
+await agendaEvents.update(event.id, { status: novoStatus });
+const billing = await billingOrchestrator.applyStatusChange({ ... });
+// Se billing.needsConfirmation, mostrar dialog. Se erro, considerar rollback do status.
+```
+
+### 7.2 ✅ Reverse confirm via `needsConfirmation` no return
+
+Quando orchestrator detecta reverse com record paid (realizado paid → agendado) ou pacote saldo consumido:
+
+```js
+// Primeira chamada — sem decisions
+const r = await billingOrchestrator.applyStatusChange({ event, fromStatus: 'realizado', toStatus: 'agendado' });
+// r = { ok: false, needsConfirmation: true, options: [
+//   { key: 'cancel_pending', label: 'Cancelar cobrança pendente', amount: 200 },
+//   { key: 'refund_paid', label: 'Estornar pagamento', amount: 200 },
+//   { key: 'manual', label: 'Resolver manualmente depois' }
+// ] }
+
+// Caller mostra dialog → user escolhe → re-chama
+const r2 = await billingOrchestrator.applyStatusChange({
+    event, fromStatus: 'realizado', toStatus: 'agendado',
+    decisions: { reverseCleanup: 'refund_paid' }
+});
+// r2 = { ok: true, actions: [{ type: 'refunded', recordId, amount }] }
+```
+
+### 7.3 ✅ Transação via RPC `apply_billing_status_transition`
+
+Toda mudança financeira de transição roda em RPC dedicada. Tudo ou nada. RPC entra como migration durante Módulo 4. Composable orchestrator faz apenas:
+1. Resolve state atual (snapshot read-only)
+2. Calcula decisões (state machine no JS)
+3. Chama RPC com plano completo (`p_actions jsonb`)
+4. RPC executa em ordem dentro de uma transação SQL
+
+Signature proposta da RPC:
+```sql
+CREATE FUNCTION public.apply_billing_status_transition(
+    p_tenant_id uuid,
+    p_event_id uuid,
+    p_actions jsonb  -- [{ kind: 'create_record', amount, due_date }, { kind: 'cancel_record', record_id }, ...]
+) RETURNS jsonb;  -- { ok, applied: [...], failed?: { kind, reason } }
+```
+
+### 7.4 ✅ Decisões #2/#3/#6 de billing — sessão dedicada antes do Módulo 4
+
+Marcar sessão dedicada (~1h) pra fechar memória `project_agenda_billing_decisoes` antes da implementação. **Bloqueador parcial do Módulo 4** — orchestrator pode ser parcialmente implementado, mas a state machine só fica completa após resolver essas 3 decisões.
+
+> ⚠️ **Pendência rastreada:** adicionar item em `dev_auditoria_items` ou agenda recorrente. Vai aparecer como **TODO inicial** na sessão de implementação do Módulo 4.
+
+---
+
+## 8. Open questions (não-bloqueantes pro design)
+
+1. **`patient_timeline` integration:** quando orchestrator cria/cancela record, devia emitir evento `pagamento_recebido` / `pagamento_vencido` em `patient_timeline`? Hoje o enum suporta, mas não vejo inserts. **Sugestão:** adicionar como trigger no banco (não no orchestrator) — fica resiliente a chamadas que escapam do orchestrator.
+
+2. **Gateway webhook (Asaas):** quando Asaas dispara webhook "paid", quem processa? Edge function dedicada que chama `financialRecords.markAsPaid(id, 'pix')`, sem passar por orchestrator (orchestrator é só pra mudanças via agenda). Documentar como caminho separado válido.
+
+3. **Repasse a terapeuta (`therapist_payouts`):** quando record fica `paid`, gera entrada em `therapist_payout_records`? Hoje não. Decisão: trigger no banco que escuta UPDATE em `financial_records.status` → cria payout. Fora do escopo do orchestrator.
+
+4. **`patient_assessments` (Fase 2):** notas clínicas com escalas têm relação com billing? Improvável — assessments são clínicos, não-monetizados. Confirmar quando implementar.
+
+---
+
+## 9. Cross-references
+
+- Memórias relevantes:
+  - `project_rpc_idempotency_cancelled.md` — RPCs ignoram cancelled
+  - `project_billing_contracts_no_updated_at.md` — gotcha de UPDATE silently failing
+  - `project_agenda_billing_decisoes.md` — 5 decisões base
+  - `project_agenda_reverse_transitions.md` — confirm dialogs pra reverter
+  - `project_cross_week_propagation.md` — pacote upfront cross-week
+  - `project_c12_antecipar_iterar.md` — antecipar pacote (Watch sync resolveu snapshot stale)
+- Audit baseline divergências Financeiro: ver `AUDIT_BASELINE.md` seção 4
+- Blueprints: `repository-blueprint.md` + `composable-blueprint.md`
+- ROADMAP: Fase 1 itens 1-4 (Monetização)
+
+---
+
+## 10. Checklist pra implementação (Módulo 4 da Fase 1)
+
+- [ ] 5 repositories criados em `features/financeiro/services/`
+- [ ] 4 composables criados em `features/financeiro/composables/`
+- [ ] `useBillingOrchestrator` com signature acima
+- [ ] State machine completa (todas transições da matriz 3.2)
+- [ ] Cache de regras dentro da instância (não módulo-level)
+- [ ] Idempotência testada (chamada 2× = noop)
+- [ ] `.eq('tenant_id', tid)` em todas mutações (defesa em profundidade)
+- [ ] RPC `apply_billing_status_transition` (decisão 7.3 opção B)
+- [ ] AgendaEventDialog migrado pra orchestrator
+- [ ] useMelissaAgenda._applyStatusDecisions migrado
+- [ ] gerarCobrancaManual callers migrados
+- [ ] useAgendaFinanceiro.js deletado
+- [ ] useFinancialRecords.js raiz deletado
+- [ ] E2E test cobrindo reverse transition (realizado paid → agendado)
+- [ ] Confirm dialogs UI implementados (memória project_agenda_reverse_transitions)
diff --git a/development/02-auditoria/PADRONIZACAO.md b/development/02-auditoria/PADRONIZACAO.md
new file mode 100644
index 0000000..c19f372
--- /dev/null
+++ b/development/02-auditoria/PADRONIZACAO.md
@@ -0,0 +1,161 @@
+# Padronização — Sweep estrutural pré-MVP
+
+> **Iniciado:** 2026-05-20
+> **Deadline MVP:** 3+ meses (lançamento limpo, sem usuários)
+> **Escopo MVP:** Pacientes + Agenda + Billing + Prontuário + Financeiro avançado + Multi-tenant
+
+---
+
+## Diagnóstico
+
+Sistema tem ~487 arquivos Vue, ~75-80% MVP-ready, padronização irregular. **Agenda passou por C1-C13 + análise sênior** — é o único módulo com profundidade arquitetural. Outros módulos têm divergências (composables sem `tenant_id` consistente, SELECTs inline, page layouts inconsistentes, dialogs que não seguem o blueprint).
+
+Sem padronizar antes de escalar features novas (Fase 1 do ROADMAP), cada gap vira dívida composta.
+
+---
+
+## Estratégia em 1 frase
+
+**Agenda é a referência madura.** Extrair seus padrões em blueprints → propagar módulo a módulo → tracking em `dev_auditoria_items` com tag `padronizacao:<modulo>`. **Não tocar agenda** até a Fase 4 (apenas pendências residuais).
+
+---
+
+## Fases
+
+### Fase 0 — Fundação (3-5 dias)
+
+Extrair os blueprints faltantes a partir da agenda:
+
+- [x] `melissa-page-blueprint.md` — já existe
+- [x] `melissa-table-page-blueprint.md` — já existe
+- [x] `dialog-blueprint.md` — já existe
+- [x] `repository-blueprint.md` — entregável 1 (2026-05-20)
+- [x] `composable-blueprint.md` — entregável 2 (2026-05-20)
+- [x] `quick-create-overlay-blueprint.md` — entregável 3 (2026-05-20). Documentado como **agenda-only** com promotion criteria explícito.
+
+E baseline:
+
+- [x] Update graphify do código atual (`graphify update src/` rodou 2026-05-20)
+- [x] Audit baseline por módulo → ver `development/02-auditoria/AUDIT_BASELINE.md` (2026-05-20). 51 divergências catalogadas + 4 surpresas estruturais. **Pendente:** popular `dev_auditoria_items` no banco (decisão de batch insert vs UI).
+
+### Fase 0.5 — Pré-Fase 1 setups (pós-audit baseline)
+
+Decisões 6-9 introduzem 4 entregáveis novos antes da Fase 1:
+
+- [x] **0.5.A** Atualizar `quick-create-overlay-blueprint.md` de "agenda-only" pra universal (2026-05-20) — header reescrito, seção 9 virou "Promotion History", path convention adicionada, checklist generalizado, memória `feedback_agenda_inline_quick_create` marcada como superseded
+- [x] **0.5.B** Schema clínico modelado (2026-05-20). 4 migrations + 1 seed escritos em `database-novo/migrations/20260520000001..4_clinical_notes_*.sql` e `database-novo/seeds/seed_040_clinical_note_templates.sql`. **Não executado** — aguardando review do user pra rodar `node db.cjs migrate`. Tabelas: `clinical_notes` + `clinical_note_versions` (audit trail via trigger snapshot) + `clinical_note_templates` (6 templates do sistema: anamnese, SOAP, DAP, BIRP, evolução livre, plano padrão). FK órfã `documents.session_note_id` renomeada pra `clinical_note_id` com constraint. RLS: owner-only (CFP sigilo).
+- [x] **0.5.C** Design doc `useBillingOrchestrator` (2026-05-20) — `development/02-auditoria/DESIGN_BILLING_ORCHESTRATOR.md`. State machine de 10 transições, dependências em 4 composables/5 repositories, plano de migração faseado em 4 fases (A/B/C/D), checklist de implementação. **4 decisões resolvidas:** (1) `applyStatusChange` só financeiro, agenda separada; (2) reverse confirm via `needsConfirmation` no return; (3) transação via RPC dedicada `apply_billing_status_transition`; (4) sessão dedicada pra decisões billing #2/#3/#6 antes do Módulo 4.
+- [x] **0.5.D** Scaffold da feature `tenantship/` (2026-05-20). 7 arquivos criados em `src/features/tenantship/`: `_tenantGuards.js`, `tenantInvitesSelects.js` + `Repository.js`, `tenantMembersSelects.js` + `Repository.js`, `useTenantInvites.js`, `useTenantMembers.js`. Funções funcionais (não-stub) usando tabela existente `tenant_invites` + view `v_tenant_members_with_profiles`. **2 pendências documentadas no código:** (1) `acceptInvite()` é stub PT-BR explicando que precisa de RPC `accept_tenant_invite(p_token uuid)` — migration a criar; (2) `sendInvite()` só insere row — envio de email/WhatsApp fica pra Módulo 6 (Notificações).
+
+### Fase 1 — Padronização módulo a módulo (4-6 semanas) — **em andamento**
+
+Ordem confirmada com usuário:
+
+| # | Módulo | Por que aqui | Status |
+|---|---|---|---|
+| 1 | **Home/Dashboard + Components base** | Alta visibilidade. Inclui refactor dos 3 quick-creates promovidos (decisão 6). | ✅ **Concluído 2026-05-20** (exceto M1.6 — MelissaLayout decomposition, deferida) |
+| 2 | **Pacientes** | Núcleo de dados — alimenta agenda, prontuário, financeiro. | ✅ **Concluído 2026-05-20** (aguarda teste batch) |
+| 3 | **Prontuário/Evolução** | Schema clínico já modelado (decisão 7). | ✅ **Foundation 2026-05-20** — repositories + composables prontos. Ativa quando migrations 0.5.B rodarem. UI da aba "Prontuário evolutivo" fica pra sessão dedicada. |
+| 4 | **Financeiro/Billing** | `useBillingOrchestrator` desenhado (decisão 8). | ✅ **Foundation 2026-05-20** — 3 repositories + 4 composables novos. State machine completa + migração dos 3 callers BLOQUEADA pelas decisões #2/#3/#6 — fica pra sessão dedicada. Old `useAgendaFinanceiro.js` + `useFinancialRecords.js` continuam em paralelo. |
+| 5 | **Multi-tenant + Tenantship** | Inclui implementar feature `tenantship/` (decisão 9). | ✅ **Concluído 2026-05-20.** MembersPage em `src/views/pages/admin/MembersPage.vue` (CRUD de membros + convites) + rota `/admin/members` registrada em `routes.clinic.js`. Migration `20260520000005_accept_tenant_invite_rpc.sql` criada (RPC SECURITY DEFINER com lock FOR UPDATE anti-race). `tenantInvitesRepository.acceptInvite` agora chama RPC real (não mais stub). SaasTenantFeaturesPage refatorada — 4 queries inline + 1 RPC extraídos pra `src/services/tenantFeatureAdminService.js`. **SetupWizardPage (2648 linhas) deferido** — refator de arquivo monolítico precisa sessão dedicada. |
+| 6 | **Notificações (WhatsApp/Email)** | Depende de tudo acima. | ✅ **Foundation 2026-05-20** — `noticesSelects.js` criado + `noticeService.js` refatorado pra usar constantes. `features/conversations/services/` com repository + selects. Channel factory + refactor de `useConversations.js` (fat composable) deferidos — sessão dedicada. SMS send ainda stub. |
+
+#### Módulo 1 — sub-entregáveis
+
+- [x] **M1.1** Criar `features/medicos/` (`_tenantGuards.js`, `medicosSelects.js`, `medicosRepository.js`, `useMedicos.js`) + refatorar `CadastroRapidoMedico.vue` pra usar repository (2026-05-20). Caller único (PatientsCadastroPage) — props/emits preservados. Zero referências `supabase`/`useTenantStore`/`getOwnerId`/`getTenantId` legacy no componente. **Testado pelo user ✅**
+- [x] **M1.2** Criar `features/insurance/` (`_tenantGuards.js`, `insurancePlansSelects.js`, `insurancePlansRepository.js` com `findByName` pra uniqueness check, `useInsurancePlans.js`) + refatorar `CadastroRapidoConvenio.vue` + `InsurancePlanQuickCreateDialog.vue` (bônus da agenda) (2026-05-20). Repository agora faz duplicate check case-insensitive antes de criar — quick-create blueprint compliance. Aguardando teste.
+- [x] **M1.3** Refatorado `ComponentCadastroRapido.vue` pra usar `usePatients` composable + `getMyActiveMember()` (novo helper em `tenantship/services/tenantMembersRepository.js`) (2026-05-20). Path NÃO mudou (continua em `src/components/`) — move pra `features/patients/components/` fica pra cleanup de M2. Props deprecated mantidas pra backwards-compat dos 8 callers. **Spillover M2:** fix `patientsRepository.createPatient` (audit alta — sempre injeta owner_id do uid logado, ignora payload) + `usePatients.error: ref('')` (audit média — canon). Aguardando teste.
+- [x] **M1.4** Extraído `TEST_ACCOUNTS` de `HomeCards.vue` pra `src/config/devTestAccounts.js` (2026-05-20). HomeCards importa do novo arquivo; 6 usages funcionam idênticos.
+- [x] **M1.5** Deletado `AgendaEventDialog.vue.bak` (não estava no git, 155KB órfão no disco) (2026-05-20).
+- [ ] **M1.6** Decomposição parcial `MelissaLayout.vue` (sessão dedicada — pode ficar pra depois)
+
+#### Módulo 2 — sub-entregáveis (2026-05-20, sem pausas de teste)
+
+- [x] **M2.1** Criar `patientsSelects.js` (11 constantes — PATIENTS_SELECT_BASE + cross-feature: sessões, financial, documents, messages, recurrences, support_contacts, groups, tags). Estender `patientsRepository.js` com 15 funções novas + `resolveTenantId` helper local. Cross-feature reads ficam no patients até M4/M6 padronizarem (documentado nos comments).
+- [x] **M2.2** `usePatientDetail.js` refatorado — 4 funções internas (getPatientById, getPatientRelations, getGroupsByIds, getTagsByIds) movidas pra repository. Composable agora é thin wrapper.
+- [x] **M2.3** `usePatientFinancial.js` refatorado — `_lastPatientId` movido DENTRO da function (audit alta resolvida: state não vaza mais entre instâncias). 4 mutations (load/markPaid/markUnpaid/createRecord) delegam ao repository.
+- [x] **M2.4** `usePatientSessions.js` refatorado — list+create+updateStatus via repository. Pattern virtual→materialize preservado usando `findSessionByRecurrence` + `createPatientSession` com recurrence_id/date. Recurrence expansion (useRecurrence) intacta. `supabase.auth.getUser()` mantido como context resolution (não é data query).
+- [x] **M2.5** Quatro composables simples refatorados em paralelo: `usePatientMessages`, `usePatientDocuments`, `usePatientRecurrences`, `usePatientSupportContacts`. Cada um delega list+mutations ao repository.
+- [x] **M2.6** Cleanups: `usePatients.js` upgraded pra Tipo A canônico completo (load/getById/create/update/remove com loading/error/re-throw consistente).
+
+**Resultado:** zero `supabase.from(...)` em qualquer composable de `features/patients/composables/`. Todos os 8 composables seguem Tipo A do blueprint. `_lastPatientId` não vaza mais.
+| 2 | **Pacientes** | Núcleo de dados — alimenta agenda, prontuário, financeiro. |
+| 3 | **Prontuário/Evolução** | Schema clínico já modelado (decisão 7). Migration já aplicada. |
+| 4 | **Financeiro/Billing** | `useBillingOrchestrator` já desenhado (decisão 8). |
+| 5 | **Multi-tenant + Tenantship** | Inclui implementar feature `tenantship/` (decisão 9). |
+| 6 | **Notificações (WhatsApp/Email)** | Depende de tudo acima. |
+
+**Por módulo, sempre:**
+1. Ler estado atual
+2. Diff vs blueprints
+3. Listar divergências em `dev_auditoria_items` (tag `padronizacao:<modulo>` + severidade)
+4. Plano de fix
+5. Executar
+6. Testar (persistir HANDOFF+wiki+memória **antes** do teste manual)
+7. Commit
+8. Atualizar tracker
+9. Log no wiki
+
+### Fase 2 — Hotspots Graphify (paralela)
+
+Do `project_graphify_findings_20260504`:
+- [ ] `convertToPatient` duplicado
+- [ ] Supabase client triplo
+- [ ] 348 nós fracos
+- [ ] Setup Wizard cohesion 0.05
+
+### Fase 3 — Gaps de MVP (Fase 1 do ROADMAP)
+
+- [🟡] **Gateway Asaas (Fase A foundation 2026-05-21)** — Design doc + 2 migrations (tables + RLS) + client service + 3 Edge Function stubs (create-payment-record, cancel-payment, sync-payment). Schema: `asaas_customers`, `asaas_payments`, `asaas_webhook_events` + 5 colunas em `payment_settings`. Fase B (implementação real) depende de credenciais + decisão modelo negócio (A/B/C). Ver `development/02-auditoria/DESIGN_ASAAS_GATEWAY.md`.
+- [🟡] **Compliance CFP (#5/#8/#9 done · #6/#7 deferred · 2026-05-21)** —
+  - #5 (registro profissional): migration `20260521000003_profiles_professional_registration.sql` — adiciona `professional_registration_type` (CHECK 8 conselhos) + `_number` + `_uf`.
+  - #8 (nome social): JÁ INTEGRADO — `patients.nome_social` schema existia + UI em 7 arquivos.
+  - #9 (especialidades): `20260521000004_specialties.sql` (tabela + profile_specialties M:N + RLS) + `seed_050_specialties.sql` (33 specialties) + `src/services/specialtiesService.js`.
+  - **#6 consent forms DEFERRED**: schema `document_templates` existe; falta seed + UI editor + workflow.
+  - **#7 assinatura DEFERRED**: schema `document_signatures` existe com status flow completo; falta portal UI pra paciente.
+- [ ] E2E Playwright crítico (#16)
+- [ ] Sentry (#18)
+
+### Fase 4 — Agenda residual (por último)
+
+- [ ] Popover snapshot stale → `ev.id` + computed
+- [ ] Reverse transition confirm dialogs (realizado paid, faltou multa, pacote saldo)
+- [ ] Replicação Rail (AgendaTerapeutaPage) + Clínica (AgendaClinicaPage)
+- [ ] C12 antecipar — iterar UX
+- [ ] Doc de ajuda completa
+
+---
+
+## Decisões tomadas
+
+### Estratégicas iniciais (2026-05-20)
+1. **Ordem dos módulos** ✅ Confirmada acima
+2. **Tracker** ✅ Reusar `dev_auditoria_items` com tag `padronizacao:<modulo>`. Zero migration. View materializada agrupa por módulo se virar útil pra UI.
+3. **Cadência** ✅ Validação por entregável (cada blueprint vira sessão antes de propagar)
+4. **Agenda intocada** ✅ Até Fase 4
+5. **Skills novas** Só `/audit-module <nome>` — minimalista. Outras só se emergir necessidade.
+
+### Pós-audit baseline (2026-05-20)
+6. **Quick-create blueprint** ✅ **Promover pra universal** (3 candidates já existem fora da agenda). Refatorar `CadastroRapidoMedico.vue` + `CadastroRapidoConvenio.vue` + `ComponentCadastroRapido.vue` em paralelo no módulo 1.
+7. **Schema clínico do prontuário** ✅ **Modelar agora** (sessão dedicada antes da Fase 1). Sai com migration pronta de `patient_notes`/`clinic_sessions`/anamnese/evolução/plano terapêutico.
+8. **Overlap billing agenda ↔ financeiro** ✅ **Consolidar em 1 composable orquestrador** (`useBillingOrchestrator`). Resolve risco double-billing antes do refactor de Financeiro.
+9. **Convites/membership** ✅ **Feature separada `tenantship/`** com services + composables + página `/admin/members`. Semântica clara: gestão de membership.
+
+---
+
+## Antipadrão a evitar
+
+- ❌ Refatorar tudo de uma vez (= nunca lançar)
+- ❌ Tocar agenda durante a sweep (= regressão garantida)
+- ❌ Pular o tracking em `dev_auditoria_items` (= perder rastreabilidade)
+- ❌ Aplicar blueprint sem antes auditar divergências (= refazer trabalho)
+
+---
+
+## Referências
+
+- Blueprints: `D:\leonohama\AgenciaPsi.com.br\Sistema\agenciapsi-primesakai\blueprints/`
+- Agenda canônica: `src/features/agenda/services/` + `src/features/agenda/composables/useAgendaEvents.js`
+- Tracker: tabela `dev_auditoria_items` (UI em `/saas/desenvolvimento`)
+- Memória: `project_padronizacao_sweep.md`
+- ROADMAP de features (não confundir): `development/04-roadmap/ROADMAP.md`
diff --git a/src/features/agenda/components/AgendaEventDialog.vue.bak b/src/features/agenda/components/AgendaEventDialog.vue.bak
deleted file mode 100644
index ce78190..0000000
--- a/src/features/agenda/components/AgendaEventDialog.vue.bak
+++ /dev/null
@@ -1,3522 +0,0 @@
-<!--
-|--------------------------------------------------------------------------
-| Agência PSI
-|--------------------------------------------------------------------------
-| Criado e desenvolvido por Leonardo Nohama
-|
-| Tecnologia aplicada à escuta.
-| Estrutura para o cuidado.
-|
-| Arquivo: src/features/agenda/components/AgendaEventDialog.vue
-| Data: 2026
-| Local: São Carlos/SP — Brasil
-|--------------------------------------------------------------------------
-| © 2026 — Todos os direitos reservados
-|--------------------------------------------------------------------------
--->
-<script setup>
-import { computed, ref, watch, nextTick } from 'vue';
-import { generateGoogleCalendarLink, formatGCalDate, addMinutesToHHMM } from '@/utils/googleCalendarLink';
-import { useRouter, useRoute } from 'vue-router';
-import Select from 'primevue/select';
-import Textarea from 'primevue/textarea';
-import DatePicker from 'primevue/datepicker';
-import InputNumber from 'primevue/inputnumber';
-import RadioButton from 'primevue/radiobutton';
-import Message from 'primevue/message';
-import { useConfirm } from 'primevue/useconfirm';
-import { useToast } from 'primevue/usetoast';
-import { supabase } from '@/lib/supabase/client';
-import ComponentCadastroRapido from '@/components/ComponentCadastroRapido.vue';
-import AgendaEventoFinanceiroPanel from '@/components/agenda/AgendaEventoFinanceiroPanel.vue';
-import { useServices } from '@/features/agenda/composables/useServices';
-import { useCommitmentServices } from '@/features/agenda/composables/useCommitmentServices';
-import { usePatientDiscounts } from '@/features/agenda/composables/usePatientDiscounts';
-import { useInsurancePlans } from '@/features/agenda/composables/useInsurancePlans';
-import { getPatientAgendaPermissions } from '@/composables/usePatientLifecycle';
-
-function patientInitials(nome) {
-    const parts = String(nome || '')
-        .trim()
-        .split(/\s+/)
-        .filter(Boolean);
-    if (!parts.length) return '?';
-    if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
-    return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
-}
-
-const props = defineProps({
-    modelValue: { type: Boolean, default: false },
-    eventRow: { type: Object, default: null },
-    initialStartISO: { type: String, default: '' },
-    initialEndISO: { type: String, default: '' },
-
-    ownerId: { type: String, default: '' },
-    planOwnerId: { type: String, default: '' }, // owner dos convênios (clínica); fallback: ownerId
-    allowOwnerEdit: { type: Boolean, default: false },
-    ownerOptions: { type: Array, default: () => [] },
-
-    tenantId: { type: String, default: '' },
-
-    commitmentOptions: { type: Array, default: () => [] },
-    presetCommitmentId: { type: [String, null], default: null },
-    lockCommitment: { type: Boolean, default: false },
-
-    restrictPatientsToOwner: { type: Boolean, default: false },
-    patientScopeOwnerId: { type: String, default: null },
-
-    workRules: { type: Array, default: () => [] },
-    blockedDates: { type: Array, default: () => [] },
-    agendaSettings: { type: Object, default: null },
-    allEvents: { type: Array, default: () => [] },
-    pausasSemanais: { type: Array, default: () => [] },
-    feriados: { type: Array, default: () => [] },
-
-    // Rota para cadastro completo de paciente (abre em nova aba)
-    newPatientRoute: { type: String, default: '' }
-});
-
-const emit = defineEmits(['update:modelValue', 'save', 'delete', 'updateSeriesEvent', 'editSeriesOccurrence', 'updated']);
-const confirm = useConfirm();
-const toast = useToast();
-const router = useRouter();
-const route = useRoute();
-
-const visible = computed({
-    get: () => props.modelValue,
-    set: (v) => emit('update:modelValue', v)
-});
-
-const step = ref(1);
-const isEdit = computed(() => !!props.eventRow?.id || !!props.eventRow?.is_occurrence);
-
-const allowBack = computed(() => !props.lockCommitment && !props.presetCommitmentId);
-
-// ── série ─────────────────────────────────────────────────
-const hasSerie = computed(() => !!(props.eventRow?.recurrence_id || props.eventRow?.serie_id || props.eventRow?.is_occurrence));
-
-const currentRecurrenceDate = computed(() => props.eventRow?.recurrence_date || props.eventRow?.inicio_em?.slice(0, 10) || null);
-
-const editScope = ref('somente_este');
-
-const isFirstOccurrence = computed(() => {
-    if (!hasSerie.value) return false;
-    const rDate = props.eventRow?.recurrence_date || props.eventRow?.original_date;
-    if (!rDate) return false;
-    if (serieEvents.value?.length) {
-        const dates = serieEvents.value
-            .map((e) => e.recurrence_date || e.original_date)
-            .filter(Boolean)
-            .sort();
-        return dates[0] === rDate;
-    }
-    return false;
-});
-
-const editScopeOptions = computed(() => [
-    { value: 'somente_este', label: 'Somente esta sessão' },
-    { value: 'este_e_seguintes', label: 'Esta e as seguintes', disabled: isFirstOccurrence.value },
-    { value: 'todos', label: 'Todas da série' },
-    { value: 'todos_sem_excecao', label: 'Todas sem exceção' }
-]);
-
-// ── recorrência (criação / sessão avulsa) ──────────────────
-// 'avulsa' | 'semanal' | 'quinzenal' | 'diasEspecificos'
-const recorrenciaType = ref('avulsa');
-
-const freqOpcoes = [
-    { value: 'avulsa', label: 'Avulsa' },
-    { value: 'semanal', label: 'Semanal' },
-    { value: 'quinzenal', label: 'Quinzenal' },
-    { value: 'diasEspecificos', label: 'Dias específicos' }
-];
-
-const diasSemanaOpcoes = [
-    { value: 1, short: 'Seg' },
-    { value: 2, short: 'Ter' },
-    { value: 3, short: 'Qua' },
-    { value: 4, short: 'Qui' },
-    { value: 5, short: 'Sex' },
-    { value: 6, short: 'Sáb' },
-    { value: 0, short: 'Dom' }
-];
-const diasSelecionados = ref([]);
-
-function toggleDiaSelecionado(dow) {
-    const idx = diasSelecionados.value.indexOf(dow);
-    if (idx === -1) diasSelecionados.value.push(dow);
-    else diasSelecionados.value.splice(idx, 1);
-}
-
-function setHoje() {
-    form.value.dia = new Date();
-}
-
-// Seletor de quantidade
-const qtdSessoesMode = ref('4');
-const qtdSessoesCustom = ref(12);
-
-const qtdSessoesOpcoes = [
-    { value: '4', label: '4 sessões' },
-    { value: '8', label: '8 sessões' },
-    { value: '12', label: '12 sessões' },
-    { value: 'personalizar', label: 'Personalizar' }
-];
-
-const qtdSessoesEfetiva = computed(() => {
-    if (qtdSessoesMode.value === '4') return 4;
-    if (qtdSessoesMode.value === '8') return 8;
-    if (qtdSessoesMode.value === '12') return 12;
-    return Math.max(1, Number(qtdSessoesCustom.value || 1));
-});
-
-const diaSemanaRecorrencia = computed(() => {
-    const d = form.value.dia ? new Date(form.value.dia) : new Date();
-    return d.getDay();
-});
-
-const proximasOcorrencias = computed(() => {
-    if (recorrenciaType.value === 'avulsa' || !form.value.dia) return [];
-    const result = [];
-    const total = qtdSessoesEfetiva.value;
-
-    if (recorrenciaType.value === 'semanal' || recorrenciaType.value === 'quinzenal') {
-        const step = recorrenciaType.value === 'quinzenal' ? 14 : 7;
-        const cursor = new Date(form.value.dia);
-        while (result.length < total) {
-            result.push(new Date(cursor));
-            cursor.setDate(cursor.getDate() + step);
-        }
-    } else if (recorrenciaType.value === 'diasEspecificos') {
-        if (!diasSelecionados.value.length) return [];
-        const sorted = [...diasSelecionados.value].sort((a, b) => a - b);
-        const start = new Date(form.value.dia);
-        const cur = new Date(start);
-        let safety = 0;
-        while (result.length < total && safety < 1000) {
-            if (sorted.includes(cur.getDay()) && cur >= start) result.push(new Date(cur));
-            cur.setDate(cur.getDate() + 1);
-            safety++;
-        }
-    }
-    return result;
-});
-
-const dataFimCalculada = computed(() => {
-    const oc = proximasOcorrencias.value;
-    return oc.length ? oc[oc.length - 1] : null;
-});
-
-const totalOcorrencias = computed(() => proximasOcorrencias.value.length);
-
-const dataLimiteManual = ref(null);
-function isForaDoPlano(d) {
-    if (!dataLimiteManual.value) return false;
-    return new Date(d) > new Date(dataLimiteManual.value);
-}
-const sessoesForaDoPlano = computed(() => proximasOcorrencias.value.filter((d) => isForaDoPlano(d)).length);
-
-function _conflictForDate(date) {
-    if (!date) return null;
-    const dow = date.getDay();
-    const iso = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
-
-    // 1. Folga
-    if (props.workRules?.length && !props.workRules.some((r) => Number(r.dia_semana) === dow)) {
-        return { type: 'folga', label: 'dia de folga' };
-    }
-
-    // 2. Feriado
-    const feriado = (props.feriados || []).find((f) => {
-        const fiso = f.date || f.data || f.iso || '';
-        return String(fiso).slice(0, 10) === iso;
-    });
-    if (feriado) return { type: 'feriado', label: `feriado: ${feriado.name || feriado.nome || ''}` };
-
-    // 3. Bloqueio manual (blockedDates já são ISO strings YYYY-MM-DD)
-    if ((props.blockedDates || []).includes(iso)) {
-        return { type: 'bloqueado', label: 'dia bloqueado' };
-    }
-
-    // 4. Pausa (checa se o horário da sessão sobrepõe alguma pausa do dia)
-    if (form.value.startTime) {
-        const [sh, sm] = form.value.startTime.split(':').map(Number);
-        const slotS = sh * 60 + sm;
-        const slotE = slotS + (form.value.duracaoMin || 50);
-        const pausas = (props.pausasSemanais || []).filter((p) => p.dia_semana == null || Number(p.dia_semana) === dow);
-        for (const p of pausas) {
-            const [ph, pm] = String(p.hora_inicio || '00:00')
-                .split(':')
-                .map(Number);
-            const [eh, em] = String(p.hora_fim || '00:00')
-                .split(':')
-                .map(Number);
-            if (slotS < eh * 60 + em && slotE > ph * 60 + pm) {
-                return { type: 'pausa', label: 'horário de pausa' };
-            }
-        }
-    }
-
-    return null;
-}
-
-const ocorrenciasComConflito = computed(() =>
-    proximasOcorrencias.value.map((d) => ({
-        date: d,
-        conflict: _conflictForDate(d)
-    }))
-);
-
-const totalConflitos = computed(() => ocorrenciasComConflito.value.filter((o) => o.conflict).length);
-
-// ── commitments ────────────────────────────────────────────
-const commitmentCards = computed(() => {
-    const list = Array.isArray(props.commitmentOptions) ? props.commitmentOptions : [];
-    const prio = new Map([['session', 0]]);
-    return [...list].sort((a, b) => {
-        const pa = prio.has(a.native_key) ? prio.get(a.native_key) : 99;
-        const pb = prio.has(b.native_key) ? prio.get(b.native_key) : 99;
-        if (pa !== pb) return pa - pb;
-        return String(a.name || '').localeCompare(String(b.name || ''), 'pt-BR');
-    });
-});
-
-function isNativeSession(c) {
-    return String(c?.native_key || '').toLowerCase() === 'session';
-}
-
-const form = ref(resetForm());
-
-// ── ConfirmDialog para status sensíveis (cancelado / remarcar) ────────────
-const _prevStatus = ref(null);
-const _skipStatusWatch = ref(false);
-watch(
-    () => form.value?.status,
-    async (newVal, oldVal) => {
-        if (_skipStatusWatch.value) return;
-        if (!isEdit.value || !form.value?.id) return;
-        if (newVal !== 'cancelado' && newVal !== 'remarcado') return;
-
-        _prevStatus.value = oldVal;
-
-        const isCancelar = newVal === 'cancelado';
-        confirm.require({
-            header: isCancelar ? 'Cancelar sessão' : 'Remarcar sessão',
-            message: isCancelar ? 'Tem certeza que deseja cancelar esta sessão? O status será salvo imediatamente.' : 'Tem certeza que deseja marcar esta sessão para remarcação? O status será salvo imediatamente.',
-            icon: isCancelar ? 'pi pi-times-circle' : 'pi pi-refresh',
-            acceptLabel: 'Sim, confirmar',
-            rejectLabel: 'Não',
-            acceptSeverity: isCancelar ? 'danger' : 'warn',
-            accept: async () => {
-                try {
-                    const { data, error } = await supabase.from('agenda_eventos').update({ status: newVal }).eq('id', form.value.id).select().single();
-                    if (error) throw error;
-                    toast.add({ severity: 'success', summary: 'Status atualizado', detail: `Sessão marcada como ${labelStatusSessao(newVal)}.`, life: 3000 });
-                    emit('updated', data);
-                } catch (e) {
-                    toast.add({ severity: 'error', summary: 'Erro', detail: e?.message || 'Não foi possível atualizar o status.', life: 4000 });
-                    form.value.status = _prevStatus.value;
-                }
-            },
-            reject: () => {
-                form.value.status = _prevStatus.value;
-            }
-        });
-    }
-);
-
-// ── Precificação / Serviços ─────────────────────────────────────────
-const { services, getDefaultPrice, load: loadServices } = useServices();
-const { loadItems: _csLoadItems, saveItems: saveCommitmentItems, loadItemsOrTemplate: _csLoadItemsOrTemplate } = useCommitmentServices();
-const { loadActive: loadActiveDiscount } = usePatientDiscounts();
-const { plans: insurancePlans, load: loadInsurancePlans } = useInsurancePlans();
-const selectedPlanService = ref(null);
-
-const activePlans = computed(() => insurancePlans.value.filter((p) => p.active !== false));
-
-const planServices = computed(() => {
-    if (!form.value.insurance_plan_id) return [];
-    return (insurancePlans.value.find((p) => p.id === form.value.insurance_plan_id)?.insurance_plan_services || []).filter((s) => s.active);
-});
-let _servicesLoaded = false;
-
-async function ensureServicesLoaded() {
-    if (_servicesLoaded || !props.ownerId) return;
-    _servicesLoaded = true;
-    await loadServices(props.ownerId);
-}
-
-function applyDefaultPrice() {
-    // Pula quando pago: o preço vem dos commitmentItems, não de um default
-    if (billingType.value === 'particular') return;
-    // Só auto-preenche se price ainda não foi definido manualmente (ou é novo evento)
-    if (!isEdit.value) {
-        const suggested = getDefaultPrice();
-        if (suggested != null) form.value.price = suggested;
-    }
-}
-
-// ── Itens de serviço (commitment_services) ──────────────────────────
-const commitmentItems = ref([]);
-const servicePickerSel = ref(null);
-const serieValorMode = ref('multiplicar'); // 'multiplicar' | 'dividir'
-
-const billingType = ref('particular'); // 'gratuito' | 'particular' | 'convenio'
-const _restoringConvenio = ref(false); // flag para ignorar watch durante restauração
-const billingTypeOptions = [
-    { label: 'Gratuito', value: 'gratuito' },
-    { label: 'Particular', value: 'particular' },
-    { label: 'Convênio', value: 'convenio' }
-];
-
-watch(billingType, (val) => {
-    if (val === 'gratuito') {
-        commitmentItems.value = [];
-        form.value.price = 0;
-        form.value.insurance_plan_id = null;
-        form.value.insurance_guide_number = null;
-        form.value.insurance_value = null;
-        selectedPlanService.value = null;
-    }
-    if (val === 'particular') {
-        form.value.insurance_plan_id = null;
-        form.value.insurance_guide_number = null;
-        form.value.insurance_value = null;
-        selectedPlanService.value = null;
-    }
-    if (val === 'convenio') {
-        commitmentItems.value = [];
-        servicePickerSel.value = null;
-    }
-});
-
-const isDynamic = computed(() => (props.agendaSettings?.slot_mode ?? 'fixed') === 'dynamic');
-
-const totalFromItems = computed(() => commitmentItems.value.reduce((sum, item) => sum + (item.final_price ?? 0), 0));
-
-// Duração calculada como soma de services.duration_min dos itens (slot_mode=dynamic)
-const dynamicDuration = computed(() => {
-    if (!isDynamic.value) return null;
-    return commitmentItems.value.reduce((sum, item) => {
-        const svc = services.value.find((s) => s.id === item.service_id);
-        return sum + (svc?.duration_min ?? 0);
-    }, 0);
-});
-
-// Preço exibido no resumo: total dos itens quando há itens, form.price caso contrário
-const displayPrice = computed(() => (commitmentItems.value.length > 0 ? totalFromItems.value : form.value.price));
-
-// Aviso informativo de valor total da série (não altera os valores gravados)
-const serieValorAviso = computed(() => {
-    if (recorrenciaType.value === 'avulsa' || !commitmentItems.value.length) return null;
-    const n = qtdSessoesEfetiva.value;
-    if (!n || !totalFromItems.value) return null;
-    if (serieValorMode.value === 'multiplicar') {
-        return `Total da série: ${fmtBRL(totalFromItems.value * n)} (${fmtBRL(totalFromItems.value)} × ${n} sessões)`;
-    }
-    return `Valor por sessão: ${fmtBRL(totalFromItems.value / n)} (${fmtBRL(totalFromItems.value)} ÷ ${n} sessões)`;
-});
-
-// Sync: total dos itens → form.price
-watch(totalFromItems, (total) => {
-    if (commitmentItems.value.length > 0) form.value.price = total;
-});
-
-// Sync: duração dinâmica → form.duracaoMin (slot_mode=dynamic)
-watch(dynamicDuration, (dur) => {
-    if (isDynamic.value && dur != null && dur > 0) form.value.duracaoMin = dur;
-});
-
-function calcFinalPrice(unit_price, quantity, discount_pct, discount_flat) {
-    const subtotal = Number(unit_price) * Number(quantity);
-    const discPct = subtotal * (Number(discount_pct ?? 0) / 100);
-    const discFlat = Number(discount_flat ?? 0);
-    return Math.max(0, subtotal - discPct - discFlat);
-}
-
-async function addItem(svc) {
-    if (!svc?.id) return;
-    // Regra: não duplicar — incrementa quantity do item existente
-    const existing = commitmentItems.value.find((i) => i.service_id === svc.id);
-    if (existing) {
-        existing.quantity++;
-        existing.final_price = calcFinalPrice(existing.unit_price, existing.quantity, existing.discount_pct, existing.discount_flat);
-        return;
-    }
-    const unit_price = Number(svc.price);
-    const patientId = form.value.patient_id ?? form.value.paciente_id ?? null;
-    let discount_pct = 0;
-    let discount_flat = 0;
-
-    if (patientId && props.ownerId) {
-        const discount = await loadActiveDiscount(props.ownerId, patientId);
-        if (discount) {
-            discount_pct = Number(discount.discount_pct ?? 0);
-            discount_flat = Number(discount.discount_flat ?? 0);
-        }
-    }
-
-    commitmentItems.value.push({
-        service_id: svc.id,
-        service_name: svc.name,
-        quantity: 1,
-        unit_price,
-        discount_pct,
-        discount_flat,
-        final_price: calcFinalPrice(unit_price, 1, discount_pct, discount_flat)
-    });
-}
-
-function removeItem(index) {
-    commitmentItems.value.splice(index, 1);
-    // Quando lista esvazia em modo dynamic, restaura duração padrão
-    if (commitmentItems.value.length === 0 && isDynamic.value) {
-        form.value.duracaoMin = props.agendaSettings?.session_duration_min ?? 50;
-    }
-}
-
-function onItemChange(item) {
-    item.final_price = calcFinalPrice(item.unit_price, item.quantity, item.discount_pct, item.discount_flat);
-}
-
-async function _loadCommitmentItemsForEvent(eventId) {
-    const ruleId = props.eventRow?.recurrence_id ?? null;
-    const isCustomized = props.eventRow?.services_customized ?? false;
-    // Lê os dados de convênio diretamente do eventRow (form.value pode ter sido limpo por watches)
-    const origPlanId = props.eventRow?.insurance_plan_id ?? null;
-    const origGuide = props.eventRow?.insurance_guide_number ?? null;
-    const origInsValue = props.eventRow?.insurance_value != null ? Number(props.eventRow.insurance_value) : null;
-
-    function applyConvenio() {
-        const origPsId = props.eventRow?.insurance_plan_service_id ?? null;
-        _restoringConvenio.value = true;
-        form.value.insurance_plan_id = origPlanId;
-        form.value.insurance_guide_number = origGuide;
-        form.value.insurance_value = origInsValue;
-        form.value.insurance_plan_service_id = origPsId;
-        billingType.value = 'convenio';
-        nextTick(() => {
-            if (origPsId && planServices.value.find((s) => s.id === origPsId)) {
-                selectedPlanService.value = origPsId;
-            } else {
-                selectedPlanService.value = null;
-            }
-            _restoringConvenio.value = false;
-        });
-    }
-
-    if (!eventId && !ruleId) {
-        commitmentItems.value = [];
-        if (origPlanId) applyConvenio();
-        else billingType.value = 'particular';
-        return;
-    }
-    try {
-        commitmentItems.value = ruleId ? await _csLoadItemsOrTemplate(eventId, ruleId, { allowEmpty: isCustomized }) : await _csLoadItems(eventId);
-        if (origPlanId) applyConvenio();
-        else billingType.value = commitmentItems.value.length > 0 ? 'particular' : 'gratuito';
-    } catch (e) {
-        console.warn('[AgendaEventDialog] commitment_services load error:', e?.message);
-        commitmentItems.value = [];
-        if (origPlanId) applyConvenio();
-        else billingType.value = 'gratuito';
-    }
-}
-
-function fmtBRL(v) {
-    if (v == null) return '—';
-    return Number(v).toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' });
-}
-
-const selectedCommitment = computed(() => {
-    const id = form.value.commitment_id;
-    if (!id) return null;
-    return commitmentCards.value.find((x) => x.id === id) || null;
-});
-const selectedCommitmentName = computed(() => selectedCommitment.value?.name || '—');
-const selectedCommitmentFields = computed(() => {
-    const fields = selectedCommitment.value?.fields;
-    return Array.isArray(fields) ? fields : [];
-});
-
-const requiresPatient = computed(() => isNativeSession(selectedCommitment.value));
-const isSessionEvent = computed(() => requiresPatient.value);
-// Bloqueia troca de paciente quando editando sessão que já tinha paciente vinculado
-const patientLocked = computed(() => isEdit.value && isSessionEvent.value && !!props.eventRow?.paciente_id);
-const hasInsurance = computed(() => !!form.value.insurance_plan_id);
-
-// ── jornada ────────────────────────────────────────────────
-function _fmtH(hhmm) {
-    const [h, m] = String(hhmm || '00:00')
-        .slice(0, 5)
-        .split(':')
-        .map(Number);
-    return m > 0 ? `${h}h${String(m).padStart(2, '0')}` : `${h}h`;
-}
-
-const jornadaDialog = computed(() => {
-    const rules = props.workRules;
-    if (!rules?.length) return null;
-    const d = form.value.dia ? new Date(form.value.dia) : new Date();
-    const dow = d.getDay();
-    const rule = rules.find((r) => Number(r.dia_semana) === dow);
-    if (!rule) return { text: 'Este é um dia de folga na sua agenda.', isOff: true };
-    const inicio = String(rule.hora_inicio || '').slice(0, 5);
-    const fim = String(rule.hora_fim || '').slice(0, 5);
-    const [h1, m1] = inicio.split(':').map(Number);
-    const [h2, m2] = fim.split(':').map(Number);
-    const totalMin = h2 * 60 + m2 - (h1 * 60 + m1);
-    const durH = Math.floor(totalMin / 60);
-    const durM = totalMin % 60;
-    const durStr = durM > 0 ? `${durH}h${String(durM).padStart(2, '0')}` : `${durH}h`;
-    return { text: `Jornada: das ${_fmtH(inicio)} às ${_fmtH(fim)} (${durStr})`, isOff: false };
-});
-
-// ── bloqueio de dia ────────────────────────────────────────
-const blockedSet = computed(() => new Set(props.blockedDates || []));
-const formDayISO = computed(() => {
-    const d = form.value.dia ? new Date(form.value.dia) : null;
-    if (!d) return '';
-    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
-});
-const isDayBlocked = computed(() => !!formDayISO.value && blockedSet.value.has(formDayISO.value));
-const isSessionBlockedByDay = computed(() => isDayBlocked.value && isSessionEvent.value);
-
-const isDiaFolga = computed(() => {
-    if (!form.value.dia || !props.workRules?.length) return false;
-    const dow = new Date(form.value.dia).getDay();
-    return !props.workRules.some((r) => Number(r.dia_semana) === dow);
-});
-
-// ── time picker ────────────────────────────────────────────
-const timePickerOpen = ref(false);
-const samePatientConflict = ref(null);
-
-const modalidadeOptions = [
-    { label: 'Presencial', value: 'presencial' },
-    { label: 'Online', value: 'online' }
-];
-
-// ── novo paciente ──────────────────────────────────────────
-const cadRapidoOpen = ref(false);
-
-function abrirCadastroCompleto() {
-    const route = props.newPatientRoute || '/therapist/patients/cadastro';
-    window.open(route, '_blank', 'noopener');
-}
-
-function onPatientCreatedRapido(p) {
-    // auto-seleciona o paciente recém-criado
-    if (!p) return;
-    const nome = p.nome_completo || p.nome || p.name || '';
-    form.value.paciente_id = p.id;
-    form.value.paciente_nome = nome;
-    form.value.paciente_avatar = p.avatar_url || null;
-    cadRapidoOpen.value = false;
-}
-
-// ── paciente picker ────────────────────────────────────────
-const pacientePickerOpen = ref(false);
-const pacienteSearch = ref('');
-const pacientesLoading = ref(false);
-const pacientesError = ref('');
-const patients = ref([]);
-
-const filteredPatients = computed(() => {
-    const q = String(pacienteSearch.value || '')
-        .trim()
-        .toLowerCase();
-    // Somente pacientes Ativos podem ser selecionados para novos agendamentos
-    const list = (patients.value || []).filter((p) => p.status === 'Ativo');
-    if (!q) return list;
-    return list.filter((p) => {
-        const nome = String(p.nome || '').toLowerCase();
-        const email = String(p.email || '').toLowerCase();
-        const tel = String(p.telefone || '').toLowerCase();
-        return nome.includes(q) || email.includes(q) || tel.includes(q);
-    });
-});
-
-function selectCommitment(c) {
-    if (!c?.id) return;
-    form.value.commitment_id = c.id;
-    form.value.extra_fields = {};
-    if (Array.isArray(c.fields)) {
-        for (const f of c.fields) form.value.extra_fields[f.key] = '';
-    }
-    step.value = 2;
-    if (requiresPatient.value) loadPatients(true);
-}
-
-function goBack() {
-    if (isEdit.value || !allowBack.value) return;
-    step.value = 1;
-    form.value.commitment_id = null;
-    form.value.paciente_id = null;
-    form.value.paciente_nome = '';
-}
-
-function openPacientePicker() {
-    if (!requiresPatient.value) return;
-    pacientePickerOpen.value = true;
-    loadPatients(false);
-}
-
-function clearPatientsCache() {
-    patients.value = [];
-    pacientesError.value = '';
-    pacienteSearch.value = '';
-}
-
-async function loadPatients(force = false) {
-    try {
-        if (pacientesLoading.value) return;
-        if (!force && patients.value?.length) return;
-        pacientesError.value = '';
-        pacientesLoading.value = true;
-
-        let q = supabase.from('patients').select('id,nome_completo,email_principal,telefone,status,avatar_url,tenant_id,responsible_member_id,created_at').order('created_at', { ascending: false }).limit(500);
-
-        if (props.tenantId) q = q.eq('tenant_id', props.tenantId);
-        if (props.restrictPatientsToOwner && props.patientScopeOwnerId) {
-            q = q.eq('responsible_member_id', props.patientScopeOwnerId);
-        }
-
-        const { data, error } = await q;
-        if (error) throw error;
-
-        patients.value = (data || []).map((r) => ({
-            id: r.id,
-            nome: r.nome_completo ?? '',
-            email: r.email_principal ?? '',
-            telefone: r.telefone ?? '',
-            status: r.status ?? '',
-            avatar_url: r.avatar_url ?? ''
-        }));
-    } catch (e) {
-        pacientesError.value = e?.message || 'Falha ao carregar pacientes.';
-        patients.value = [];
-    } finally {
-        pacientesLoading.value = false;
-    }
-}
-
-function selectPaciente(p) {
-    if (!p?.id) return;
-    form.value.paciente_id = p.id;
-    form.value.paciente_nome = p.nome || '';
-    form.value.paciente_avatar = p.avatar_url || '';
-    pacientePickerOpen.value = false;
-}
-function clearPaciente() {
-    form.value.paciente_id = null;
-    form.value.paciente_nome = '';
-    form.value.paciente_avatar = '';
-    samePatientConflict.value = null;
-}
-
-// ── quando abre ────────────────────────────────────────────
-watch(
-    () => props.modelValue,
-    async (open) => {
-        if (!open) return;
-        await nextTick();
-        console.log('[AgendaEventDialog] abriu — eventRow:', JSON.parse(JSON.stringify(props.eventRow || {})));
-        console.log('[AgendaEventDialog] isEdit:', isEdit.value, 'hasSerie:', hasSerie.value);
-
-        _skipStatusWatch.value = true;
-        form.value = resetForm();
-        await nextTick();
-        _skipStatusWatch.value = false;
-        samePatientConflict.value = null;
-        recorrenciaType.value = 'avulsa';
-        diasSelecionados.value = [];
-        dataLimiteManual.value = null;
-        qtdSessoesMode.value = '4';
-        qtdSessoesCustom.value = 12;
-        editScope.value = 'somente_este';
-        serieValorMode.value = 'multiplicar';
-
-        if (isEdit.value && form.value.paciente_id && !form.value.paciente_nome) {
-            supabase
-                .from('patients')
-                .select('id, nome_completo')
-                .eq('id', form.value.paciente_id)
-                .maybeSingle()
-                .then(({ data }) => {
-                    if (data?.nome_completo) form.value.paciente_nome = data.nome_completo;
-                });
-        }
-
-        if (hasSerie.value) loadSerieEvents();
-        else serieEvents.value = [];
-
-        if (isEdit.value) {
-            step.value = 2;
-        } else {
-            const preset = props.presetCommitmentId;
-            if (preset) {
-                form.value.commitment_id = preset;
-                step.value = 2;
-            } else step.value = 1;
-        }
-
-        clearPatientsCache();
-        if (requiresPatient.value) loadPatients(true);
-
-        // Pré-carrega serviços para auto-fill de preço
-        ensureServicesLoaded();
-        const insuranceOwner = props.planOwnerId || props.ownerId;
-        if (insuranceOwner) {
-            await loadInsurancePlans(insuranceOwner);
-            // planServices é computed — atualiza automaticamente após insurancePlans carregar
-        }
-
-        // Reset convênio (será restaurado por _loadCommitmentItemsForEvent se necessário)
-        selectedPlanService.value = null;
-        _restoringConvenio.value = false;
-
-        // Reset e carrega itens de serviço do evento (commitment_services)
-        commitmentItems.value = [];
-        servicePickerSel.value = null;
-        // Carrega serviços para eventos reais (form.value.id) ou template para ocorrências virtuais (só recurrence_id)
-        // _loadCommitmentItemsForEvent determina o billingType correto (incluindo 'convenio')
-        if (isEdit.value && (form.value.id || props.eventRow?.recurrence_id)) {
-            _loadCommitmentItemsForEvent(form.value.id);
-        } else {
-            billingType.value = 'particular';
-        }
-    }
-);
-
-watch(
-    () => [props.tenantId, props.restrictPatientsToOwner, props.patientScopeOwnerId],
-    () => {
-        if (!visible.value) return;
-        clearPatientsCache();
-        if (requiresPatient.value) loadPatients(true);
-    }
-);
-
-// Auto-fill price when commitment changes (novo evento apenas)
-watch(
-    () => form.value.commitment_id,
-    async (newId) => {
-        if (!newId || isEdit.value || !visible.value) return;
-        await ensureServicesLoaded();
-        applyDefaultPrice();
-    }
-);
-
-watch(
-    () => form.value.insurance_plan_id,
-    (planId) => {
-        if (_restoringConvenio.value) return;
-        selectedPlanService.value = null;
-        form.value.insurance_plan_service_id = null;
-        if (!planId) {
-            // Limpa campos de convênio ao desmarcar
-            form.value.insurance_value = null;
-            form.value.insurance_guide_number = null;
-            return;
-        }
-        // Ao selecionar convênio: exclusividade — remove serviços do caminho A
-        commitmentItems.value = [];
-        servicePickerSel.value = null;
-    }
-);
-
-function onProcedureSelect(psId) {
-    form.value.insurance_plan_service_id = psId ?? null;
-    if (!psId) {
-        form.value.insurance_value = null;
-        return;
-    }
-    const ps = planServices.value.find((s) => s.id === psId);
-    form.value.insurance_value = ps?.value != null ? Number(ps.value) : null;
-}
-
-watch(
-    () => [form.value.paciente_id, form.value.dia?.toString()],
-    async () => {
-        const pid = form.value.paciente_id;
-        samePatientConflict.value = null;
-        if (!pid || !isSessionEvent.value || !visible.value) return;
-
-        const d = form.value.dia ? new Date(form.value.dia) : new Date();
-        const dayStart = new Date(d.getFullYear(), d.getMonth(), d.getDate()).toISOString();
-        const dayEnd = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1).toISOString();
-
-        let q = supabase.from('agenda_eventos').select('id, inicio_em, fim_em, titulo').eq('patient_id', pid).gte('inicio_em', dayStart).lt('inicio_em', dayEnd).limit(1);
-
-        if (form.value.id) q = q.neq('id', form.value.id);
-        const { data } = await q.maybeSingle();
-        samePatientConflict.value = data || null;
-    }
-);
-
-// ── Check solicitações pendentes no horário ───────────────────
-const solicitacaoPendente = ref(null);
-
-watch(
-    () => [form.value.dia?.toString(), form.value.startTime],
-    async ([dia, startTime]) => {
-        solicitacaoPendente.value = null;
-        if (!isSessionEvent.value || !visible.value || isEdit.value) return;
-        if (!props.ownerId || !dia || !startTime) return;
-
-        const d = new Date(form.value.dia);
-        const isoDate = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
-        const { data } = await supabase
-            .from('agendador_solicitacoes')
-            .select('id, paciente_nome, paciente_sobrenome, paciente_email')
-            .eq('owner_id', props.ownerId)
-            .eq('status', 'pendente')
-            .eq('data_solicitada', isoDate)
-            .eq('hora_solicitada', startTime)
-            .maybeSingle();
-        solicitacaoPendente.value = data || null;
-    }
-);
-
-function goToAgendamentosRecebidos() {
-    visible.value = false;
-    const prefix = route.path.startsWith('/admin') ? '/admin' : '/therapist';
-    router.push(`${prefix}/agendamentos-recebidos`);
-}
-
-function goToConveniosConfig() {
-    visible.value = false;
-    const prefix = route.path.startsWith('/admin') ? '/admin' : '/therapist';
-    router.push(`${prefix}/configuracoes/convenios`);
-}
-
-// ── duração / slots ────────────────────────────────────────
-// grouped duration options: default preset first, then com pausa, then sem pausa
-const duracaoOptions = computed(() => {
-    const defaultDur = props.agendaSettings?.session_duration_min || 50;
-    const defaultGap = props.agendaSettings?.session_break_min || 0;
-
-    const ALL_PRESETS = [
-        { label: '30 min', dur: 30, gap: 0 },
-        { label: '40 min', dur: 40, gap: 0 },
-        { label: '45 min', dur: 45, gap: 15 },
-        { label: '50 min', dur: 50, gap: 10 },
-        { label: '60 min', dur: 60, gap: 0 },
-        { label: '90 min', dur: 90, gap: 0 },
-        { label: '2h', dur: 120, gap: 0 }
-    ];
-
-    const defaultItem = {
-        label: `${defaultDur} min${defaultGap > 0 ? ` + ${defaultGap}min pausa` : ''}  ✦ padrão`,
-        value: defaultDur
-    };
-
-    const others = ALL_PRESETS.filter((p) => p.dur !== defaultDur);
-    const wBreak = others.filter((p) => p.gap > 0);
-    const noBreak = others.filter((p) => p.gap === 0);
-
-    const groups = [{ label: 'Padrão da agenda', items: [defaultItem] }];
-    if (wBreak.length) groups.push({ label: 'Com pausa', items: wBreak.map((p) => ({ label: `${p.label} + ${p.gap}min pausa`, value: p.dur })) });
-    if (noBreak.length) groups.push({ label: 'Sem pausa', items: noBreak.map((p) => ({ label: p.label, value: p.dur })) });
-    return groups;
-});
-
-// ── time slot helpers ──────────────────────────────────────────
-function hhmmToMin(hhmm) {
-    const [h, m] = String(hhmm || '00:00')
-        .slice(0, 5)
-        .split(':')
-        .map(Number);
-    return (h || 0) * 60 + (m || 0);
-}
-function minToHHMM(min) {
-    const h = Math.floor(min / 60) % 24;
-    const m = min % 60;
-    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
-}
-
-// Slots disponíveis no dia selecionado (respeitando jornada + pausas + eventos existentes)
-const availableSlots = computed(() => {
-    const dia = form.value.dia;
-    if (!dia || !props.workRules?.length) return [];
-    const dow = new Date(dia).getDay();
-    const dur = props.agendaSettings?.session_duration_min || 50;
-    const gap = props.agendaSettings?.session_break_min || 0;
-    const cycle = Math.max(1, dur + gap);
-
-    const windows = (props.workRules || [])
-        .filter((r) => Number(r.dia_semana) === dow && r.ativo !== false)
-        .map((r) => ({ start: String(r.hora_inicio || '').slice(0, 5), end: String(r.hora_fim || '').slice(0, 5) }))
-        .sort((a, b) => a.start.localeCompare(b.start));
-    if (!windows.length) return [];
-
-    const breaks = (props.pausasSemanais || []).filter((p) => p.dia_semana == null || Number(p.dia_semana) === dow).map((p) => ({ s: hhmmToMin(p.hora_inicio || '00:00'), e: hhmmToMin(p.hora_fim || '00:00') }));
-
-    // eventos já agendados no mesmo dia (para marcar como ocupado)
-    const todayStr = dia instanceof Date ? `${dia.getFullYear()}-${String(dia.getMonth() + 1).padStart(2, '0')}-${String(dia.getDate()).padStart(2, '0')}` : String(dia).slice(0, 10);
-    const busySlots = (props.allEvents || [])
-        .filter((e) => {
-            if (!e.inicio_em) return false;
-            return e.inicio_em.slice(0, 10) === todayStr && e.id !== form.value.id;
-        })
-        .map((e) => ({
-            s: hhmmToMin(e.inicio_em.slice(11, 16)),
-            e: e.fim_em ? hhmmToMin(e.fim_em.slice(11, 16)) : hhmmToMin(e.inicio_em.slice(11, 16)) + dur
-        }));
-
-    const slots = [];
-    for (const w of windows) {
-        const wStart = hhmmToMin(w.start);
-        const wEnd = hhmmToMin(w.end);
-        let t = wStart;
-        while (t + dur <= wEnd) {
-            const aEnd = t + dur;
-            const brk = breaks.find((b) => !(aEnd <= b.s || t >= b.e));
-            if (brk) {
-                t = brk.e;
-                continue;
-            }
-            const busy = busySlots.some((b) => !(aEnd <= b.s || t >= b.e));
-            slots.push({ hhmm: minToHHMM(t), endHhmm: minToHHMM(aEnd), busy });
-            t += cycle;
-        }
-    }
-    const seen = new Set();
-    return slots.filter((s) => {
-        if (seen.has(s.hhmm)) return false;
-        seen.add(s.hhmm);
-        return true;
-    });
-});
-
-const PERIODOS = [
-    { label: 'Manhã', icon: 'pi-sun', from: '05:00', to: '12:00' },
-    { label: 'Tarde', icon: 'pi-cloud', from: '12:00', to: '18:00' },
-    { label: 'Noite', icon: 'pi-moon', from: '18:00', to: '24:00' }
-];
-const selectedPeriodo = ref(null);
-
-// Apenas períodos que têm ao menos 1 slot disponível
-const activePeriodos = computed(() => PERIODOS.filter((p) => availableSlots.value.some((s) => s.hhmm >= p.from && s.hhmm < p.to)));
-
-// Set dos horários online pré-configurados (para marcar nos pills)
-const onlineConfigSet = computed(() => new Set((onlineSlots.value || []).map((s) => s.hhmm)));
-
-const filteredSlots = computed(() => {
-    const base = selectedPeriodo.value ? availableSlots.value.filter((s) => s.hhmm >= selectedPeriodo.value.from && s.hhmm < selectedPeriodo.value.to) : availableSlots.value;
-    return base.map((s) => ({ ...s, isOnlineConfigured: onlineConfigSet.value.has(s.hhmm) }));
-});
-
-function selectSlot(hhmm) {
-    // monta um Date com a hora selecionada e atualiza startTimeDate
-    const [h, m] = hhmm.split(':').map(Number);
-    const d = new Date();
-    d.setHours(h, m, 0, 0);
-    startTimeDate.value = d;
-}
-
-// ── online slots ──────────────────────────────────────────────
-const onlineSlots = ref([]);
-const loadingOnlineSlots = ref(false);
-
-watch(
-    [() => form.value.dia, () => form.value.modalidade],
-    async ([dia, mod]) => {
-        if (mod !== 'online' || !dia || !props.ownerId) {
-            onlineSlots.value = [];
-            return;
-        }
-        const dow = new Date(dia).getDay();
-        loadingOnlineSlots.value = true;
-        try {
-            const { data } = await supabase.from('agenda_online_slots').select('time').eq('owner_id', props.ownerId).eq('weekday', dow).eq('enabled', true).order('time');
-            onlineSlots.value = (data || []).map((s) => ({ hhmm: String(s.time || '').slice(0, 5) }));
-        } catch {
-            onlineSlots.value = [];
-        } finally {
-            loadingOnlineSlots.value = false;
-        }
-    },
-    { immediate: true }
-);
-
-const onlineAtivo = computed(() => !!props.agendaSettings?.online_ativo);
-const onlineDisponivel = computed(() => (form.value.modalidade === 'online' ? onlineAtivo.value && onlineSlots.value.length > 0 : true));
-
-const dayWorkRule = computed(() => {
-    if (!form.value.dia || !props.workRules?.length) return null;
-    const dow = new Date(form.value.dia).getDay();
-    return props.workRules.find((r) => Number(r.dia_semana) === dow) ?? null;
-});
-
-// ── série: info do banner ──────────────────────────────────
-const serieDiaSemana = computed(() => {
-    if (props.eventRow?.serie_dia_semana != null) return Number(props.eventRow.serie_dia_semana);
-    const iso = props.eventRow?.inicio_em;
-    if (iso) return new Date(iso).getDay();
-    return form.value.dia ? new Date(form.value.dia).getDay() : null;
-});
-const serieHoraDisplay = computed(() => {
-    if (props.eventRow?.serie_hora) return props.eventRow.serie_hora;
-    return form.value.startTime || null;
-});
-
-// ── série: lista de sessões ────────────────────────────────
-const serieEvents = ref([]);
-const serieLoading = ref(false);
-const pillDeleteMenuRef = ref(null);
-const pillDeleteTarget = ref(null);
-
-const statusOptions = [
-    { label: 'Agendado', value: 'agendado' },
-    { label: 'Realizado', value: 'realizado' },
-    { label: 'Faltou', value: 'faltou' },
-    { label: 'Cancelado', value: 'cancelado' },
-    { label: 'Remarcar', value: 'remarcado' }
-];
-
-const serieCountByStatus = computed(() => {
-    const counts = {};
-    for (const ev of serieEvents.value) {
-        const s = ev._status || 'agendado';
-        counts[s] = (counts[s] || 0) + 1;
-    }
-    return counts;
-});
-
-const pillDeleteMenuItems = computed(() => {
-    if (!pillDeleteTarget.value) return [];
-    const ev = pillDeleteTarget.value;
-    return [
-        { label: 'Remover apenas esta', icon: 'pi pi-minus-circle', command: () => onPillDelete(ev, 'somente_este') },
-        { label: 'Remover esta e as seguintes', icon: 'pi pi-forward', command: () => onPillDelete(ev, 'este_e_seguintes') },
-        { separator: true },
-        { label: 'Remover todas as futuras', icon: 'pi pi-trash', command: () => onPillDelete(ev, 'todos') }
-    ];
-});
-
-function isPast(iso) {
-    return iso ? new Date(iso) < new Date() : false;
-}
-
-// ── Permissões de agenda por status do paciente ───────────────────────────
-const agendaPerms = computed(() => getPatientAgendaPermissions(form.value.paciente_status || ''));
-
-// Sessão atual é futura? (para edição: usa inicio_em do evento original)
-const isSessionFuture = computed(() => {
-    if (!isEdit.value) return true;
-    const iso = props.eventRow?.inicio_em;
-    return iso ? new Date(iso) > new Date() : true;
-});
-
-// Arquivado editando sessão passada → somente leitura
-const isArchivedPastEdit = computed(() => isEdit.value && form.value.paciente_status === 'Arquivado' && !isSessionFuture.value);
-
-// Inativo editando sessão futura → remarcar bloqueado
-const isInativoFutureEdit = computed(() => isEdit.value && form.value.paciente_status === 'Inativo' && isSessionFuture.value);
-
-// StatusOptions com remarcar desabilitado para Inativo
-const statusOptionsFiltered = computed(() => [
-    { label: 'Agendado', value: 'agendado' },
-    { label: 'Realizado', value: 'realizado' },
-    { label: 'Faltou', value: 'faltou' },
-    { label: 'Cancelado', value: 'cancelado' },
-    { label: 'Remarcar', value: 'remarcado', disabled: isInativoFutureEdit.value }
-]);
-function fmtWeekdayShort(iso) {
-    return new Date(iso).toLocaleDateString('pt-BR', { weekday: 'short' }).replace('.', '').slice(0, 3);
-}
-function fmtDayNum(iso) {
-    return new Date(iso).getDate();
-}
-function fmtMonthShort(iso) {
-    return new Date(iso).toLocaleDateString('pt-BR', { month: 'short' }).replace('.', '');
-}
-
-// Gera datas de ocorrência a partir de uma regra de recorrência
-function generateRuleDates(rule) {
-    const { type, interval = 1, weekdays = [], start_date, end_date, max_occurrences } = rule;
-    if (!start_date || !weekdays?.length) return [];
-    const maxOcc = Math.min(max_occurrences || 365, 365);
-    const endLimit = end_date ? new Date(end_date + 'T23:59:59') : null;
-    const dates = [];
-
-    if (type === 'custom_weekdays') {
-        const cursor = new Date(start_date + 'T12:00:00');
-        let safety = 0;
-        while (dates.length < maxOcc && safety < 2000) {
-            safety++;
-            if (endLimit && cursor > endLimit) break;
-            if (weekdays.includes(cursor.getDay())) dates.push(cursor.toISOString().slice(0, 10));
-            cursor.setDate(cursor.getDate() + 1);
-        }
-    } else {
-        // weekly (interval=1) ou quinzenal (interval=2)
-        const cursor = new Date(start_date + 'T12:00:00');
-        while (dates.length < maxOcc) {
-            if (endLimit && cursor > endLimit) break;
-            dates.push(cursor.toISOString().slice(0, 10));
-            cursor.setDate(cursor.getDate() + 7 * (interval || 1));
-        }
-    }
-    return dates;
-}
-
-async function loadSerieEvents() {
-    const rid = props.eventRow?.recurrence_id ?? props.eventRow?.serie_id ?? null;
-    if (!rid) {
-        serieEvents.value = [];
-        return;
-    }
-    serieLoading.value = true;
-    try {
-        // 1. Regra de recorrência
-        const { data: rule, error: ruleErr } = await supabase.from('recurrence_rules').select('*').eq('id', rid).maybeSingle();
-        if (ruleErr) throw ruleErr;
-
-        // 2. Exceções (canceladas, feriados, etc.)
-        const { data: excData } = await supabase.from('recurrence_exceptions').select('original_date, type, reason').eq('recurrence_id', rid);
-        const exMap = new Map((excData || []).map((e) => [e.original_date, e]));
-
-        // 3. Eventos reais já materializados em agenda_eventos
-        const { data: realData } = await supabase.from('agenda_eventos').select('id, inicio_em, fim_em, status, recurrence_date').eq('recurrence_id', rid).is('mirror_of_event_id', null).order('inicio_em', { ascending: true });
-        const realMap = new Map((realData || []).map((e) => [e.recurrence_date || e.inicio_em?.slice(0, 10), e]));
-
-        // 4. Gera as datas a partir da regra
-        const dates = rule ? generateRuleDates(rule) : [];
-        const startTime = rule?.start_time || '00:00:00';
-        const durMin = rule?.duration_min || 50;
-
-        // 5. Monta a lista
-        const list = dates.map((dateISO) => {
-            const real = realMap.get(dateISO);
-            const exc = exMap.get(dateISO);
-            const isCancelled = exc?.type === 'cancel_session' || exc?.type === 'holiday_block';
-            const [sh, sm] = String(startTime).slice(0, 5).split(':').map(Number);
-            const inicioStr = real?.inicio_em || `${dateISO}T${startTime}`;
-            const fimDate = new Date(`${dateISO}T${startTime}`);
-            fimDate.setMinutes(fimDate.getMinutes() + durMin);
-            const fimStr = real?.fim_em || fimDate.toISOString();
-            return {
-                id: real?.id || null,
-                inicio_em: inicioStr,
-                fim_em: fimStr,
-                status: real?.status || (isCancelled ? 'cancelado' : 'agendado'),
-                recurrence_date: dateISO,
-                _status: real?.status || (isCancelled ? 'cancelado' : 'agendado'),
-                _is_virtual: !real?.id,
-                _cancelled: isCancelled,
-                _reason: exc?.reason || null
-            };
-        });
-
-        // Adiciona reais que não estão na lista gerada (edge cases)
-        for (const [dateISO, real] of realMap) {
-            if (!dates.includes(dateISO)) {
-                list.push({
-                    id: real.id,
-                    inicio_em: real.inicio_em,
-                    fim_em: real.fim_em,
-                    status: real.status || 'agendado',
-                    recurrence_date: dateISO,
-                    _status: real.status || 'agendado',
-                    _is_virtual: false,
-                    _cancelled: false,
-                    _reason: null
-                });
-            }
-        }
-
-        list.sort((a, b) => new Date(a.inicio_em) - new Date(b.inicio_em));
-        serieEvents.value = list;
-    } catch (e) {
-        console.error('[serie] erro ao carregar:', e);
-        serieEvents.value = [];
-    } finally {
-        serieLoading.value = false;
-    }
-}
-
-function onPillEditClick(ev) {
-    emit('editSeriesOccurrence', {
-        id: ev.id,
-        recurrence_date: ev.recurrence_date,
-        inicio_em: ev.inicio_em,
-        fim_em: ev.fim_em,
-        is_virtual: ev._is_virtual
-    });
-}
-
-function onPillStatusChange(ev) {
-    emit('updateSeriesEvent', {
-        id: ev.id,
-        status: ev._status,
-        recurrence_date: ev.recurrence_date,
-        inicio_em: ev.inicio_em,
-        fim_em: ev.fim_em,
-        is_virtual: ev._is_virtual
-    });
-    // Se era virtual, recarrega a lista após a página materializar o evento
-    // (necessário para obter o id real e evitar duplo INSERT)
-    if (ev._is_virtual) {
-        setTimeout(() => loadSerieEvents(), 700);
-    }
-}
-
-function onPillDeleteClick(ev, event) {
-    pillDeleteTarget.value = ev;
-    nextTick(() => pillDeleteMenuRef.value?.toggle(event));
-}
-
-function onPillDelete(ev, mode) {
-    const isTodos = mode === 'todos';
-    confirm.require({
-        header: isTodos ? 'Encerrar toda a série' : 'Excluir sessão recorrente',
-        message: isTodos
-            ? 'Todos os agendamentos futuros da série serão removidos permanentemente. Esta sessão será mantida como avulsa. Esta ação é irreversível.'
-            : mode === 'este_e_seguintes'
-              ? 'Esta sessão e todas as seguintes serão removidas. Tem certeza?'
-              : 'Esta sessão será cancelada. Tem certeza?',
-        icon: isTodos ? 'pi pi-trash' : 'pi pi-exclamation-triangle',
-        acceptClass: 'p-button-danger',
-        acceptLabel: isTodos ? 'Sim, encerrar série' : 'Confirmar',
-        rejectLabel: 'Cancelar',
-        accept: () =>
-            emit('delete', {
-                id: ev.id,
-                editMode: mode,
-                recurrence_id: props.eventRow?.recurrence_id ?? props.eventRow?.serie_id ?? null,
-                original_date: ev.recurrence_date || (ev.inicio_em ? ev.inicio_em.slice(0, 10) : null),
-                serie_id: props.eventRow?.serie_id ?? null
-            })
-    });
-}
-
-// Aviso de conflito de horário (não bloqueia, só informa)
-const timeConflict = computed(() => {
-    if (!form.value.dia || !form.value.startTime || !inicioDateTime.value) return null;
-    const dur = form.value.duracaoMin || 50;
-    const breakMin = props.agendaSettings?.session_break_min || 0;
-    const slotS = inicioDateTime.value.getTime();
-    const slotE = slotS + dur * 60000;
-
-    const d = new Date(form.value.dia);
-    const dayISO = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
-
-    const currentRow = props.eventRow;
-    const dayEvts = (props.allEvents || []).filter((e) => {
-        if (!e.inicio_em) return false;
-        // Exclui evento real pelo id
-        if (form.value.id && e.id === form.value.id) return false;
-        // Exclui ocorrência virtual pelo recurrence_id + original_date
-        if (currentRow?.is_occurrence && e.is_occurrence && e.recurrence_id && e.recurrence_id === currentRow.recurrence_id && String(e.original_date || '').slice(0, 10) === String(currentRow.original_date || '').slice(0, 10)) return false;
-        const es = new Date(e.inicio_em);
-        return `${es.getFullYear()}-${String(es.getMonth() + 1).padStart(2, '0')}-${String(es.getDate()).padStart(2, '0')}` === dayISO;
-    });
-
-    for (const evt of dayEvts) {
-        const evtS = new Date(evt.inicio_em).getTime();
-        const evtE = new Date(evt.fim_em || evt.inicio_em).getTime() + breakMin * 60000;
-        if (slotS < evtE && slotE > evtS) {
-            const nome = evt.paciente_nome || 'outro compromisso';
-            return `Conflito com "${nome}" às ${fmtTime(new Date(evt.inicio_em))}`;
-        }
-    }
-
-    // Pausas do dia
-    const dow = d.getDay();
-    const pausas = (props.pausasSemanais || []).filter((p) => p.hora_inicio && p.hora_fim && (p.dia_semana == null || Number(p.dia_semana) === dow));
-    if (pausas.length && form.value.startTime) {
-        const [sh, sm] = form.value.startTime.split(':').map(Number);
-        const sS = sh * 60 + sm;
-        const sE = sS + dur;
-        for (const p of pausas) {
-            const [ph, pm] = String(p.hora_inicio).split(':').map(Number);
-            const [eh, em] = String(p.hora_fim).split(':').map(Number);
-            const pS = ph * 60 + pm;
-            const pE = eh * 60 + em;
-            if (sS < pE && sE > pS) return `Horário coincide com uma pausa (${p.hora_inicio}–${p.hora_fim})`;
-        }
-    }
-
-    return null;
-});
-
-const startTimeDate = computed({
-    get() {
-        const t = form.value.startTime;
-        if (!t) return null;
-        const [h, m] = String(t).split(':').map(Number);
-        const d = new Date();
-        d.setHours(h, m, 0, 0);
-        return d;
-    },
-    set(v) {
-        if (!v) {
-            form.value.startTime = null;
-            return;
-        }
-        form.value.startTime = `${String(v.getHours()).padStart(2, '0')}:${String(v.getMinutes()).padStart(2, '0')}`;
-    }
-});
-
-const inicioDateTime = computed(() => {
-    if (!form.value.dia || !form.value.startTime) return null;
-    const d = new Date(form.value.dia);
-    const [hh, mm] = String(form.value.startTime).split(':').map(Number);
-    d.setHours(hh, mm, 0, 0);
-    return d;
-});
-const fimDateTime = computed(() => {
-    if (!inicioDateTime.value) return null;
-    return addMinutesDate(inicioDateTime.value, Number(form.value.duracaoMin || 50));
-});
-const dataHoraDisplay = computed(() => {
-    const parts = [];
-    if (form.value.dia) parts.push(fmtDateBR(form.value.dia));
-    if (form.value.startTime) parts.push(form.value.startTime);
-    return parts.join(' • ');
-});
-const previewRange = computed(() => {
-    if (!inicioDateTime.value || !fimDateTime.value) return '—';
-    return `${fmtDateBR(inicioDateTime.value)} • ${fmtTime(inicioDateTime.value)} → ${fmtTime(fimDateTime.value)}`;
-});
-
-const computedTitulo = computed(() => {
-    const forced = String(form.value.titulo_custom || '').trim();
-    if (forced) return forced;
-    const comp = selectedCommitmentName.value || 'Compromisso';
-    if (requiresPatient.value) {
-        const nome = String(form.value.paciente_nome || '').trim();
-        return nome ? `${nome} [${comp}]` : comp;
-    }
-    return comp;
-});
-
-const canSave = computed(() => {
-    if (!form.value.owner_id) return false;
-    if (!form.value.dia) return false;
-    if (!form.value.startTime) return false;
-    // commitment_id é obrigatório só na criação (define o tipo do evento).
-    // Em edição, sessões antigas podem ter determined_commitment_id=null
-    // no DB — relaxar aqui evita travar o Salvar quando o usuário só
-    // quer mudar horário/observação de uma sessão pré-existente.
-    if (!isEdit.value && !form.value.commitment_id) return false;
-    if (requiresPatient.value && !form.value.paciente_id) return false;
-    if (isSessionEvent.value && billingType.value === 'particular' && commitmentItems.value.length === 0) return false;
-
-    // ── Restrições por status do paciente ────────────────────
-    if (isSessionEvent.value && form.value.paciente_status) {
-        const perms = agendaPerms.value;
-        // Criar sessão avulsa ou com recorrência: bloqueado para Inativo/Arquivado
-        if (!isEdit.value && !perms.canCreateSession) return false;
-        // Criar recorrência: bloqueado para Inativo/Arquivado
-        if (!isEdit.value && recorrenciaType.value !== 'avulsa' && !perms.canCreateRecurrence) return false;
-        // Arquivado tentando salvar sessão passada: bloqueado
-        if (isArchivedPastEdit.value) return false;
-    }
-
-    return true;
-});
-
-const headerTitle = computed(() => {
-    if (isEdit.value) return 'Editar compromisso';
-    return step.value === 1 ? 'Novo compromisso — escolha o tipo' : 'Novo compromisso';
-});
-
-// ── save / delete ──────────────────────────────────────────
-const EVENTO_TIPO = Object.freeze({ SESSAO: 'sessao' });
-
-function onSave() {
-    if (!canSave.value) return;
-
-    // Pre-check client-side de conflito de horário. O banco também rejeita
-    // via EXCLUDE constraint (agenda_eventos_sem_sobreposicao), o que vira
-    // 400 no console. Bloquear aqui economiza round-trip e silencia o erro.
-    if (timeConflict.value) {
-        toast.add({
-            severity: 'warn',
-            summary: 'Conflito de horário',
-            detail: `${timeConflict.value}. Ajuste o horário ou a duração.`,
-            life: 4500
-        });
-        return;
-    }
-
-    const inicioISO = inicioDateTime.value?.toISOString() || null;
-    const fimISO = fimDateTime.value?.toISOString() || null;
-
-    const payload = {
-        owner_id: form.value.owner_id,
-        terapeuta_id: form.value.terapeuta_id,
-        paciente_id: requiresPatient.value ? form.value.paciente_id : null,
-        patient_id: requiresPatient.value ? form.value.paciente_id : null,
-        tipo: EVENTO_TIPO.SESSAO,
-        status: form.value.status || 'agendado',
-        titulo: computedTitulo.value || null,
-        modalidade: form.value.modalidade || null,
-        observacoes: form.value.observacoes || null,
-        inicio_em: inicioISO,
-        fim_em: fimISO,
-        determined_commitment_id: form.value.commitment_id || null,
-        titulo_custom: form.value.titulo_custom || null,
-        extra_fields: Object.keys(form.value.extra_fields || {}).length ? form.value.extra_fields : null,
-        price: isSessionEvent.value ? (form.value.price ?? null) : null,
-        insurance_plan_id: isSessionEvent.value ? (form.value.insurance_plan_id ?? null) : null,
-        insurance_guide_number: isSessionEvent.value ? (form.value.insurance_guide_number ?? null) : null,
-        insurance_value: isSessionEvent.value ? (form.value.insurance_value ?? null) : null,
-        insurance_plan_service_id: isSessionEvent.value ? (form.value.insurance_plan_service_id ?? null) : null
-    };
-
-    // recorrência — só quando é sessão e não avulsa
-    let recorrencia = null;
-    if (isSessionEvent.value && recorrenciaType.value !== 'avulsa') {
-        recorrencia = {
-            tipo: 'recorrente',
-            tipoFreq: recorrenciaType.value, // 'semanal' | 'quinzenal' | 'diasEspecificos'
-            diaSemana: diaSemanaRecorrencia.value,
-            diasSemana: diasSelecionados.value, // usado em diasEspecificos
-            horaInicio: form.value.startTime ? `${form.value.startTime}:00` : null,
-            duracaoMin: form.value.duracaoMin,
-            dataFim: dataFimCalculada.value ? dataFimCalculada.value.toISOString() : null,
-            qtdSessoes: qtdSessoesEfetiva.value,
-            serieValorMode: serieValorMode.value,
-            commitmentItems: commitmentItems.value.slice()
-        };
-        recorrencia.conflitos = ocorrenciasComConflito.value.filter((o) => o.conflict).map((o) => ({ date: o.date.toISOString().slice(0, 10), conflict: o.conflict }));
-    }
-
-    // escopo de edição — só quando edita série existente
-    const emitEditMode = hasSerie.value ? editScope.value : null;
-    const emitRecurrenceId = hasSerie.value ? (props.eventRow?.recurrence_id ?? props.eventRow?.serie_id ?? null) : null;
-    const emitOriginalDate = hasSerie.value ? (props.eventRow?.original_date ?? null) : null;
-
-    emit('save', {
-        id: form.value.id,
-        payload,
-        recorrencia,
-        editMode: emitEditMode,
-        recurrence_id: emitRecurrenceId,
-        original_date: emitOriginalDate,
-        // legado — mantido para compatibilidade
-        serie_id: props.eventRow?.serie_id ?? null,
-        serviceItems: isSessionEvent.value ? commitmentItems.value.slice() : null,
-        onSaved: isSessionEvent.value
-            ? async (eventId, { markCustomized = false } = {}) => {
-                  await saveCommitmentItems(eventId, commitmentItems.value, { markCustomized });
-              }
-            : null
-    });
-}
-
-function onEncerrarSerie() {
-    confirm.require({
-        header: 'Encerrar toda a série',
-        message: 'Todos os agendamentos da série serão removidos permanentemente, incluindo exceções e recorrências. Esta sessão será mantida como avulsa. Esta ação é irreversível.',
-        icon: 'pi pi-trash',
-        acceptClass: 'p-button-danger',
-        acceptLabel: 'Sim, encerrar série',
-        rejectLabel: 'Cancelar',
-        accept: () =>
-            emit('delete', {
-                id: form.value.id,
-                editMode: 'todos',
-                recurrence_id: props.eventRow?.recurrence_id ?? props.eventRow?.serie_id ?? null,
-                original_date: props.eventRow?.original_date ?? null,
-                serie_id: props.eventRow?.serie_id ?? null
-            })
-    });
-}
-
-// ───── Lembrete manual WhatsApp (8.2) ─────
-const sendingReminder = ref(false);
-async function onSendManualReminder() {
-    if (!form.value?.id) return;
-    confirm.require({
-        header: 'Enviar lembrete WhatsApp?',
-        message: `Vou mandar o template "lembrete_sessao" pra ${form.value.paciente_nome || 'o paciente'} agora. Pode disparar?`,
-        icon: 'pi pi-whatsapp',
-        acceptLabel: 'Enviar',
-        rejectLabel: 'Cancelar',
-        accept: async () => {
-            sendingReminder.value = true;
-            try {
-                const { data, error } = await supabase.functions.invoke('send-session-reminder-manual', {
-                    body: { event_id: form.value.id }
-                });
-                if (error || !data?.ok) {
-                    const err = data?.error || error?.message || 'unknown_error';
-                    let friendly = err;
-                    if (err === 'no_phone') friendly = 'Paciente sem telefone cadastrado.';
-                    else if (err === 'invalid_phone') friendly = 'Telefone do paciente inválido.';
-                    else if (err === 'no_active_channel') friendly = 'Nenhum canal WhatsApp ativo. Configure em Configurações → WhatsApp.';
-                    else if (err === 'template_not_found') friendly = 'Template "lembrete_sessao" não encontrado. Configure em Configurações → WhatsApp.';
-                    else if (err === 'forbidden') friendly = 'Você não tem permissão pra enviar por este canal.';
-                    else if (String(err).startsWith('send_failed')) friendly = 'Não conseguimos enviar. Verifique a conexão do WhatsApp.';
-                    throw new Error(friendly);
-                }
-                toast.add({ severity: 'success', summary: 'Lembrete enviado', detail: data.to ? `Para ${data.to}` : undefined, life: 3500 });
-            } catch (e) {
-                toast.add({ severity: 'error', summary: 'Erro ao enviar lembrete', detail: e.message, life: 5000 });
-            } finally {
-                sendingReminder.value = false;
-            }
-        }
-    });
-}
-
-function onDelete() {
-    if (!form.value.id) return;
-
-    // se for evento de série, pede escopo
-    if (hasSerie.value) {
-        const isTodos = editScope.value === 'todos';
-        confirm.require({
-            header: isTodos ? 'Encerrar toda a série' : 'Excluir sessão recorrente',
-            message: isTodos ? 'Todos os agendamentos futuros da série serão removidos permanentemente. Esta sessão será mantida como avulsa. Esta ação é irreversível.' : 'Esta sessão faz parte de uma série. O que deseja remover?',
-            icon: isTodos ? 'pi pi-trash' : 'pi pi-exclamation-triangle',
-            acceptClass: 'p-button-danger',
-            acceptLabel: isTodos ? 'Sim, encerrar série' : editScopeOptions.value.find((o) => o.value === editScope.value)?.label || 'Excluir',
-            rejectLabel: 'Cancelar',
-            accept: () =>
-                emit('delete', {
-                    id: form.value.id,
-                    editMode: editScope.value,
-                    recurrence_id: props.eventRow?.recurrence_id ?? props.eventRow?.serie_id ?? null,
-                    original_date: props.eventRow?.original_date ?? null,
-                    serie_id: props.eventRow?.serie_id ?? null
-                })
-        });
-        return;
-    }
-
-    confirm.require({
-        header: 'Excluir compromisso',
-        message: 'Tem certeza? Essa ação não pode ser desfeita.',
-        icon: 'pi pi-exclamation-triangle',
-        acceptClass: 'p-button-danger',
-        acceptLabel: 'Excluir',
-        rejectLabel: 'Cancelar',
-        accept: () => emit('delete', form.value.id)
-    });
-}
-
-// ── helpers ────────────────────────────────────────────────
-function addMinutesDate(date, min) {
-    const d = new Date(date);
-    d.setMinutes(d.getMinutes() + Number(min || 0));
-    return d;
-}
-function fmtDateBR(d) {
-    const dt = d instanceof Date ? d : new Date(d);
-    return dt.toLocaleDateString('pt-BR', { day: '2-digit', month: 'short', year: 'numeric' });
-}
-function fmtDateBRLong(d) {
-    const dt = d instanceof Date ? d : new Date(d);
-    return dt.toLocaleDateString('pt-BR', { weekday: 'short', day: '2-digit', month: 'short' });
-}
-function fmtTime(d) {
-    if (!d) return '—';
-    return new Date(d).toLocaleTimeString('pt-BR', { hour: '2-digit', minute: '2-digit' });
-}
-function fmtDuracao(min) {
-    const m = Number(min || 0);
-    if (!m) return '—';
-    const h = Math.floor(m / 60);
-    const r = m % 60;
-    if (h && r) return `${h}h ${r}min`;
-    if (h) return `${h}h`;
-    return `${r}min`;
-}
-function fmtSerieHora(hora) {
-    if (!hora) return '—';
-    return String(hora).slice(0, 5);
-}
-function nomeDiaSemana(dow) {
-    const nomes = ['domingo', 'segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado'];
-    return nomes[Number(dow ?? 0)] ?? '—';
-}
-function isoToHHMM(iso) {
-    if (!iso) return null;
-    const s = String(iso);
-    if (s.endsWith('Z') || /[+-]\d{2}:\d{2}$/.test(s)) {
-        const d = new Date(s);
-        return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
-    }
-    const match = s.match(/T(\d{2}):(\d{2})/);
-    if (match) return `${match[1]}:${match[2]}`;
-    const d = new Date(s);
-    return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
-}
-function calcMinutes(a, b) {
-    try {
-        if (!a || !b) return null;
-        const ms = new Date(b).getTime() - new Date(a).getTime();
-        return Math.max(0, Math.round(ms / 60000));
-    } catch {
-        return null;
-    }
-}
-
-function resetForm() {
-    const r = props.eventRow;
-    const startISO = r?.inicio_em || props.initialStartISO || '';
-    const endISO = r?.fim_em || props.initialEndISO || '';
-    const duracaoMin = calcMinutes(startISO, endISO) || props.agendaSettings?.session_duration_min || 50;
-
-    return {
-        id: r?.id || null,
-        owner_id: r?.owner_id || props.ownerId || '',
-        terapeuta_id: r?.terapeuta_id ?? null,
-        paciente_id: r?.paciente_id ?? null,
-        paciente_nome: r?.paciente_nome ?? r?.patient_name ?? '',
-        paciente_avatar: r?.paciente_avatar ?? '',
-        paciente_status: r?.paciente_status ?? '',
-        commitment_id: r?.determined_commitment_id ?? null,
-        titulo_custom: r?.titulo_custom || '',
-        status: r?.status || 'agendado',
-        observacoes: r?.observacoes || '',
-        dia: startISO ? new Date(startISO) : new Date(),
-        startTime: startISO ? isoToHHMM(startISO) : null,
-        duracaoMin,
-        modalidade: r?.modalidade || 'presencial',
-        conflito: null,
-        extra_fields: r?.extra_fields && typeof r.extra_fields === 'object' ? { ...r.extra_fields } : {},
-        price: r?.price != null ? Number(r.price) : null,
-        insurance_plan_id: r?.insurance_plan_id ?? null,
-        insurance_guide_number: r?.insurance_guide_number ?? null,
-        insurance_value: r?.insurance_value != null ? Number(r.insurance_value) : null,
-        insurance_plan_service_id: r?.insurance_plan_service_id ?? null
-    };
-}
-
-// ── Google Calendar link ────────────────────────────────────────
-const googleCalendarUrl = computed(() => {
-    const dia = form.value.dia;
-    const hora = form.value.startTime;
-    if (!dia || !hora) return null;
-
-    const start = formatGCalDate(dia, hora);
-    const endHHMM = addMinutesToHHMM(hora, form.value.duracaoMin || 50);
-    const end = formatGCalDate(dia, endHHMM);
-
-    const paciente = form.value.paciente_nome ? ` — ${form.value.paciente_nome}` : '';
-    const title = (form.value.titulo_custom?.trim() || 'Sessão') + paciente;
-    const location = form.value.modalidade === 'online' ? 'Atendimento Online' : '';
-
-    return generateGoogleCalendarLink({
-        title,
-        description: form.value.observacoes?.trim() || '',
-        location,
-        start,
-        end
-    });
-});
-
-function labelStatusSessao(v) {
-    const map = { agendado: 'Agendado', realizado: 'Realizado', faltou: 'Faltou', cancelado: 'Cancelado', remarcado: 'Remarcado' };
-    return map[v] || '—';
-}
-function statusSeverity(v) {
-    if (v === 'agendado') return 'info';
-    if (v === 'realizado') return 'success';
-    if (v === 'faltou') return 'warn';
-    if (v === 'cancelado') return 'danger';
-    if (v === 'remarcado') return 'secondary'; // cor real via classe CSS
-    return 'secondary';
-}
-function statusExtraClass(v) {
-    return v === 'remarcado' ? 'tag-remarcado' : '';
-}
-</script>
-
-<template>
-    <Dialog v-model:visible="visible" modal :draggable="false" :dismissableMask="true" :style="{ width: '1000px', maxWidth: '96vw' }" :breakpoints="{ '960px': '96vw', '640px': '98vw' }" class="agenda-event-composer" pt:mask:class="backdrop-blur-xs">
-        <template #header>
-            <div class="w-full flex items-center justify-between gap-3">
-                <div class="flex items-center gap-2 min-w-0">
-                    <div class="header-dot shrink-0" :style="selectedCommitment?.bg_color ? { background: `#${selectedCommitment.bg_color}` } : {}" />
-                    <div class="min-w-0">
-                        <div class="font-semibold truncate text-base">{{ headerTitle }}</div>
-                        <div v-if="step === 2" class="text-xs text-color-secondary truncate">{{ previewRange }}</div>
-                    </div>
-                </div>
-
-                <!-- actions moved to footer -->
-            </div>
-        </template>
-
-        <!-- ConfirmDialog renderizado na página pai para evitar conflito de z-index com o Dialog -->
-
-        <!-- ══════════════════════════════════════════════ -->
-        <!-- STEP 1 — escolha o tipo                        -->
-        <!-- ══════════════════════════════════════════════ -->
-        <div v-if="step === 1" class="p-2">
-            <div class="mb-4 text-sm text-color-secondary">Selecione o tipo de compromisso para começar.</div>
-
-            <Message v-if="isDayBlocked" severity="warn" class="mb-4" :closable="false">
-                <i class="pi pi-lock mr-1" />
-                <span>Este dia está bloqueado. Compromissos do tipo <strong>Sessão</strong> não podem ser agendados.</span>
-            </Message>
-
-            <div class="commitment-grid">
-                <button
-                    v-for="c in commitmentCards"
-                    :key="c.id"
-                    class="commitment-card"
-                    :class="{ 'commitment-card--blocked': isDayBlocked && isNativeSession(c) }"
-                    :style="c.bg_color ? { '--card-color': `#${c.bg_color}`, boxShadow: `0 4px 20px #${c.bg_color}30` } : {}"
-                    :disabled="isDayBlocked && isNativeSession(c)"
-                    @click="isDayBlocked && isNativeSession(c) ? null : selectCommitment(c)"
-                >
-                    <div class="commitment-card__inner">
-                        <div class="commitment-card__icon" :style="c.bg_color ? { background: `#${c.bg_color}20`, color: `#${c.bg_color}` } : {}">
-                            <i :class="isNativeSession(c) ? 'pi pi-user' : 'pi pi-calendar'" />
-                        </div>
-                        <div class="min-w-0 flex-1">
-                            <div class="font-semibold truncate">{{ c.name }}</div>
-                            <div v-if="c.description" class="text-xs text-color-secondary line-clamp-2 mt-0.5">
-                                {{ c.description }}
-                            </div>
-                            <div class="flex flex-wrap gap-1 mt-2">
-                                <Tag v-if="isNativeSession(c)" value="Exige paciente" severity="info" />
-                                <Tag v-if="isDayBlocked && isNativeSession(c)" value="Dia bloqueado" severity="danger" icon="pi pi-lock" />
-                            </div>
-                        </div>
-                        <i class="pi pi-chevron-right text-color-secondary opacity-50 shrink-0 mt-1" />
-                    </div>
-                </button>
-            </div>
-        </div>
-
-        <!-- ══════════════════════════════════════════════ -->
-        <!-- STEP 2 — formulário + painel lateral          -->
-        <!-- ══════════════════════════════════════════════ -->
-        <div v-else class="composer-grid">
-            <!-- ─── COLUNA ESQUERDA — campos ─── -->
-            <div class="composer-left">
-                <!-- Avisos topo -->
-                <Message v-if="form.conflito" severity="warn" class="mb-3" :closable="false"> <span class="font-semibold">Conflito:</span> {{ form.conflito }} </Message>
-                <Message v-if="isDayBlocked && !isSessionEvent" severity="warn" class="mb-3" :closable="false">
-                    <i class="pi pi-lock mr-1" />
-                    Atenção: dia bloqueado. Este tipo pode ser salvo normalmente.
-                </Message>
-                <Message v-if="jornadaDialog" :severity="jornadaDialog.isOff ? 'warn' : 'info'" class="mb-3" :closable="false">
-                    <i :class="jornadaDialog.isOff ? 'pi pi-moon mr-1' : 'pi pi-clock mr-1'" />
-                    {{ jornadaDialog.text }}
-                </Message>
-                <Message v-if="isDiaFolga && isSessionEvent" severity="warn" class="mb-3" :closable="false">
-                    <i class="pi pi-moon mr-1" />
-                    Este dia é folga na sua jornada. Você ainda pode salvar se necessário.
-                </Message>
-
-                <!-- ── Restrições de status do paciente ───────────── -->
-                <Message v-if="isArchivedPastEdit" severity="warn" class="mb-3" :closable="false">
-                    <i class="pi pi-lock mr-1" />
-                    <b>Paciente arquivado.</b> O histórico de sessões é somente leitura.
-                </Message>
-                <Message v-if="isEdit && form.paciente_status === 'Inativo' && isSessionFuture" severity="warn" class="mb-3" :closable="false">
-                    <i class="pi pi-ban mr-1" />
-                    <b>Paciente inativo.</b> Remarcação de sessões está bloqueada.
-                </Message>
-                <Message v-if="!isEdit && isSessionEvent && form.paciente_id && !agendaPerms.canCreateSession" severity="error" class="mb-3" :closable="false">
-                    <i class="pi pi-ban mr-1" />
-                    <b>{{ form.paciente_status === 'Arquivado' ? 'Paciente arquivado.' : 'Paciente inativo.' }}</b>
-                    Novos agendamentos estão bloqueados.
-                </Message>
-
-                <!-- ── Alerta: solicitação pendente neste horário ─── -->
-                <Message v-if="solicitacaoPendente && isSessionEvent && !isEdit" severity="info" class="mb-3" :closable="false">
-                    <div class="flex items-center justify-between gap-3 w-full flex-wrap">
-                        <span>
-                            <i class="pi pi-inbox mr-1" />
-                            Solicitação pendente de
-                            <b>{{ solicitacaoPendente.paciente_nome }} {{ solicitacaoPendente.paciente_sobrenome }}</b>
-                            para este horário.
-                        </span>
-                        <Button label="Ver agendamentos recebidos" icon="pi pi-arrow-right" size="small" severity="info" outlined class="rounded-full shrink-0" @click="goToAgendamentosRecebidos" />
-                    </div>
-                </Message>
-
-                <!-- ── PACIENTE (destaque total) ──────────────────── -->
-                <div v-if="isSessionEvent" class="patient-hero mb-4">
-                    <div class="patient-hero__label">
-                        <div class="flex items-center gap-1.5">
-                            <i class="pi pi-user" />
-                            <span>Paciente</span>
-                        </div>
-                        <div class="flex items-center gap-1 ml-auto">
-                            <Button label="Cadastro Rápido" icon="pi pi-user-plus" size="small" severity="secondary" outlined class="rounded-full text-xs h-7" @click="cadRapidoOpen = true" />
-                            <Button icon="pi pi-external-link" size="small" severity="secondary" text class="rounded-full h-7 w-7" v-tooltip.top="'Cadastro completo (nova aba)'" @click="abrirCadastroCompleto" />
-                        </div>
-                    </div>
-
-                    <!-- Sem paciente selecionado -->
-                    <button v-if="!form.paciente_id" class="patient-hero__empty" @click="openPacientePicker">
-                        <div class="patient-hero__empty-icon">
-                            <i class="pi pi-user-plus" />
-                        </div>
-                        <div>
-                            <div class="font-semibold">Selecionar paciente</div>
-                            <div class="text-xs text-color-secondary">Toque para buscar</div>
-                        </div>
-                        <i class="pi pi-chevron-right ml-auto text-color-secondary opacity-50" />
-                    </button>
-
-                    <!-- Com paciente selecionado -->
-                    <div v-else class="patient-hero__selected">
-                        <Avatar v-if="form.paciente_avatar" :image="form.paciente_avatar" shape="circle" size="large" class="shrink-0" />
-                        <Avatar v-else :label="patientInitials(form.paciente_nome)" shape="circle" size="large" class="shrink-0 patient-avatar-bg" />
-                        <div class="min-w-0 flex-1">
-                            <div class="font-bold text-base truncate">{{ form.paciente_nome }}</div>
-                            <div class="flex items-center gap-1.5 flex-wrap">
-                                <span class="text-xs text-color-secondary">Paciente vinculado</span>
-                                <span
-                                    v-if="form.paciente_status === 'Inativo' || form.paciente_status === 'Arquivado'"
-                                    style="display: inline-block; background: #f97316; color: #fff; font-size: 9px; font-weight: 700; letter-spacing: 0.05em; text-transform: uppercase; padding: 1px 6px; border-radius: 3px; line-height: 1.5"
-                                    >{{ form.paciente_status === 'Arquivado' ? 'arquivado' : 'desativado' }}</span
-                                >
-                            </div>
-                        </div>
-                        <div class="flex gap-1 shrink-0">
-                            <Button v-if="!patientLocked" icon="pi pi-pencil" severity="secondary" outlined size="small" class="rounded-full h-8 w-8" v-tooltip.top="'Trocar'" @click="openPacientePicker" />
-                            <Button v-if="!patientLocked" icon="pi pi-times" severity="secondary" text size="small" class="rounded-full h-8 w-8" v-tooltip.top="'Limpar'" @click="clearPaciente" />
-                            <span v-if="patientLocked" v-tooltip.top="'Paciente não pode ser alterado após criação'" class="flex items-center gap-1 text-xs text-color-secondary px-2"><i class="pi pi-lock" /></span>
-                        </div>
-                    </div>
-
-                    <!-- Modalidade dentro do card de paciente -->
-                    <div class="patient-hero__modalidade">
-                        <span class="patient-hero__mod-label">Modalidade</span>
-                        <SelectButton v-model="form.modalidade" :options="modalidadeOptions" optionLabel="label" optionValue="value" :allowEmpty="false" size="small" />
-                    </div>
-
-                    <Message v-if="samePatientConflict && isSessionEvent" severity="warn" class="mt-2" :closable="false">
-                        Paciente já tem sessão neste dia:
-                        <b>{{ fmtTime(new Date(samePatientConflict.inicio_em)) }} → {{ fmtTime(new Date(samePatientConflict.fim_em)) }}</b>
-                    </Message>
-                </div>
-
-                <!-- ── DATA E HORÁRIO ─────────────────────────────── -->
-                <div class="field-card mb-4">
-                    <div class="field-card__header">
-                        <i class="pi pi-calendar" />
-                        <span>Data e Horário</span>
-                        <div class="flex items-center gap-1 ml-auto">
-                            <Button label="Ajustar horário" icon="pi pi-pencil" size="small" severity="secondary" outlined class="rounded-full text-xs h-7" @click="timePickerOpen = true" />
-                        </div>
-                    </div>
-                    <div class="field-card__body">
-                        <div class="time-hero" @click="timePickerOpen = true">
-                            <div class="time-hero__block">
-                                <span class="time-hero__label">Data</span>
-                                <span class="time-hero__value">{{ form.dia ? fmtDateBR(form.dia) : '—' }}</span>
-                            </div>
-                            <div class="time-hero__sep" />
-                            <div class="time-hero__block">
-                                <span class="time-hero__label">Início</span>
-                                <span class="time-hero__value">{{ form.startTime || '—' }}</span>
-                            </div>
-                            <div class="time-hero__sep" />
-                            <div class="time-hero__block">
-                                <span class="time-hero__label">Duração</span>
-                                <span class="time-hero__value">{{ fmtDuracao(form.duracaoMin) }}</span>
-                            </div>
-                            <div class="time-hero__sep" />
-                            <div class="time-hero__block">
-                                <span class="time-hero__label">Término</span>
-                                <span class="time-hero__value">{{ fimDateTime ? fmtTime(fimDateTime) : '—' }}</span>
-                            </div>
-                        </div>
-                        <Message v-if="timeConflict" severity="warn" class="m-2" :closable="false">
-                            <i class="pi pi-exclamation-triangle mr-1" />
-                            {{ timeConflict }}
-                        </Message>
-                    </div>
-                    <!-- /field-card__body -->
-                </div>
-                <!-- /field-card -->
-
-                <!-- ── STATUS DA SESSÃO ───────────────────────────── -->
-                <div v-if="isSessionEvent && isEdit" class="field-card mb-4">
-                    <div class="field-card__header">
-                        <i class="pi pi-tag" />
-                        <span>Status da Sessão</span>
-                    </div>
-                    <div class="field-card__body">
-                        <SelectButton v-model="form.status" :options="statusOptionsFiltered" optionLabel="label" optionValue="value" optionDisabled="disabled" :allowEmpty="false" :disabled="isArchivedPastEdit" class="w-full status-select-btn" />
-                    </div>
-                </div>
-
-                <!-- ── DEMAIS CAMPOS ──────────────────────────────── -->
-                <div class="fields-grid">
-                    <!-- Título (apenas para não-sessão) -->
-                    <div v-if="!isSessionEvent">
-                        <FloatLabel variant="on">
-                            <IconField>
-                                <InputIcon class="pi pi-pencil" />
-                                <InputText id="aed-titulo" v-model="form.titulo_custom" class="w-full" variant="filled" />
-                            </IconField>
-                            <label for="aed-titulo">Título</label>
-                        </FloatLabel>
-                    </div>
-
-                    <!-- Profissional -->
-                    <div v-if="allowOwnerEdit">
-                        <FloatLabel variant="on">
-                            <IconField>
-                                <InputIcon class="pi pi-briefcase" />
-                                <Select inputId="aed-owner" class="w-full" v-model="form.owner_id" :options="ownerOptions" optionLabel="label" optionValue="value" variant="filled" />
-                            </IconField>
-                            <label for="aed-owner">Profissional</label>
-                        </FloatLabel>
-                    </div>
-
-                    <!-- Campos extras do compromisso -->
-                    <template v-if="selectedCommitmentFields.length">
-                        <div v-for="f in selectedCommitmentFields" :key="f.key">
-                            <FloatLabel variant="on">
-                                <Textarea v-if="f.field_type === 'textarea'" :id="`aed-extra-${f.key}`" v-model="form.extra_fields[f.key]" class="w-full" variant="filled" rows="2" autoResize />
-                                <InputText v-else :id="`aed-extra-${f.key}`" v-model="form.extra_fields[f.key]" class="w-full" variant="filled" />
-                                <label :for="`aed-extra-${f.key}`">{{ f.label }}{{ f.required ? ' *' : '' }}</label>
-                            </FloatLabel>
-                        </div>
-                    </template>
-
-                    <!-- Observação (somente quando não é sessão — para sessões fica no card direito) -->
-                    <div v-if="!isSessionEvent" class="col-span-full">
-                        <FloatLabel variant="on">
-                            <Textarea id="aed-observacoes" v-model="form.observacoes" class="w-full" variant="filled" rows="3" autoResize />
-                            <label for="aed-observacoes">Observação</label>
-                        </FloatLabel>
-                    </div>
-                </div>
-
-                <!-- ── RECORRÊNCIAS APLICADAS ──────────────────────────── -->
-                <div v-if="hasSerie" class="serie-panel mt-4">
-                    <div class="serie-panel__header">
-                        <i class="pi pi-refresh shrink-0" />
-                        <span>Recorrências Aplicadas</span>
-                        <div v-if="!serieLoading && serieEvents.length" class="serie-panel__stats">
-                            <span>{{ serieEvents.length }} sessões</span>
-                            <span v-if="serieCountByStatus.realizado"> · {{ serieCountByStatus.realizado }} realizadas</span>
-                            <span v-if="serieCountByStatus.faltou"> · {{ serieCountByStatus.faltou }} faltaram</span>
-                            <span v-if="serieCountByStatus.cancelado"> · {{ serieCountByStatus.cancelado }} canceladas</span>
-                            <span v-if="serieCountByStatus.remarcado"> · {{ serieCountByStatus.remarcado }} para remarcar</span>
-                        </div>
-                        <span v-if="serieLoading" class="ml-auto text-xs opacity-50">Carregando…</span>
-                    </div>
-
-                    <div v-if="!serieLoading && serieEvents.length" class="serie-pills-wrap">
-                        <div
-                            v-for="ev in serieEvents"
-                            :key="ev.id || ev.recurrence_date"
-                            class="serie-pill"
-                            :class="[`serie-pill--${ev._status || 'agendado'}`, { 'serie-pill--current': ev.recurrence_date === currentRecurrenceDate, 'serie-pill--past': isPast(ev.inicio_em) }]"
-                        >
-                            <div class="serie-pill__date">
-                                <span class="serie-pill__weekday">{{ fmtWeekdayShort(ev.inicio_em) }}</span>
-                                <span class="serie-pill__daynum">{{ fmtDayNum(ev.inicio_em) }}</span>
-                                <span class="serie-pill__month">{{ fmtMonthShort(ev.inicio_em) }}</span>
-                            </div>
-                            <span class="serie-pill__time">{{ fmtTime(new Date(ev.inicio_em)) }}</span>
-                            <Select v-model="ev._status" :options="statusOptions" optionLabel="label" optionValue="value" size="small" variant="filled" class="serie-pill__status-sel" @change="onPillStatusChange(ev)" />
-                            <span v-if="ev.recurrence_date === currentRecurrenceDate" class="serie-pill__cur-badge">atual</span>
-                            <Button label="Editar" icon="pi pi-pencil" text size="small" severity="secondary" class="serie-pill__edit" v-tooltip.left="'Editar esta sessão'" @click="onPillEditClick(ev)" />
-                            <Button icon="pi pi-times" text size="small" severity="secondary" class="serie-pill__del" v-tooltip.left="'Remover'" @click="onPillDeleteClick(ev, $event)" />
-                        </div>
-                    </div>
-
-                    <div v-if="!serieLoading && !serieEvents.length" class="serie-panel__empty">Nenhuma sessão encontrada na série.</div>
-
-                    <Menu ref="pillDeleteMenuRef" :model="pillDeleteMenuItems" :popup="true" />
-                </div>
-            </div>
-
-            <!-- ─── COLUNA DIREITA — painel ─── -->
-            <div class="composer-right">
-                <!-- ── RESUMO ─────────────────────────────────────── -->
-                <div class="side-card mb-3">
-                    <div class="side-card__title">Resumo</div>
-
-                    <div class="flex items-center gap-2 mb-2">
-                        <span v-if="selectedCommitment?.bg_color" class="commit-badge" :style="{ background: `#${selectedCommitment.bg_color}20`, color: `#${selectedCommitment.bg_color}`, borderColor: `#${selectedCommitment.bg_color}40` }">{{
-                            selectedCommitmentName
-                        }}</span>
-                        <Tag v-else :value="selectedCommitmentName" severity="info" />
-                        <Tag v-if="isSessionEvent" :value="labelStatusSessao(form.status)" :severity="statusSeverity(form.status)" :class="statusExtraClass(form.status)" />
-                    </div>
-
-                    <div class="summary-row">
-                        <i class="pi pi-user summary-icon" />
-                        <span class="truncate">{{ form.paciente_nome || (isSessionEvent ? 'Sem paciente' : '—') }}</span>
-                    </div>
-                    <div class="summary-row">
-                        <i class="pi pi-calendar summary-icon" />
-                        <span class="truncate">{{ form.dia ? fmtDateBR(form.dia) : '—' }}</span>
-                    </div>
-                    <div class="summary-row">
-                        <i class="pi pi-clock summary-icon" />
-                        <span>{{ form.startTime || '—' }} → {{ fimDateTime ? fmtTime(fimDateTime) : '—' }}</span>
-                    </div>
-                    <div class="summary-row">
-                        <i class="pi pi-map-marker summary-icon" />
-                        <span class="capitalize">{{ form.modalidade || '—' }}</span>
-                    </div>
-                    <div v-if="isSessionEvent" class="summary-row">
-                        <i class="pi pi-wallet summary-icon" />
-                        <span>{{ displayPrice != null ? fmtBRL(displayPrice) : '—' }}</span>
-                    </div>
-                </div>
-
-                <!-- ── ESCOPO DE EDIÇÃO — só em modo edição de série ── -->
-                <div v-if="isEdit && hasSerie" class="side-card mb-3">
-                    <div class="side-card__title mb-2">Aplicar alterações em</div>
-                    <SelectButton v-model="editScope" :options="editScopeOptions" optionLabel="label" optionValue="value" :optionDisabled="(o) => !!o.disabled" class="w-full" size="small" />
-                    <Message v-if="isFirstOccurrence" severity="info" :closable="false" class="mt-2">
-                        <span class="text-sm"> Esta é a primeira sessão da série. Para alterar todas as ocorrências, use <b>Todos</b> ou <b>Todos sem exceção</b>. </span>
-                    </Message>
-                </div>
-
-                <!-- ── FINANCEIRO (só sessão) ────────────────────────── -->
-                <div v-if="isSessionEvent" class="side-card mb-3">
-                    <!-- SelectButton: Gratuito / Particular / Convênio -->
-                    <SelectButton v-model="billingType" :options="billingTypeOptions" optionLabel="label" optionValue="value" class="w-full mb-3" />
-
-                    <!-- PARTICULAR: seletor de serviço -->
-                    <template v-if="billingType === 'particular'">
-                        <div v-if="services.filter((s) => s.active).length" class="flex gap-2 mb-2">
-                            <Select
-                                v-model="servicePickerSel"
-                                :options="services.filter((s) => s.active)"
-                                optionLabel="name"
-                                optionValue="id"
-                                placeholder="Adicionar serviço..."
-                                class="flex-1"
-                                size="small"
-                                @update:modelValue="
-                                    (id) => {
-                                        addItem(services.find((s) => s.id === id));
-                                        servicePickerSel = null;
-                                    }
-                                "
-                            />
-                        </div>
-                    </template>
-
-                    <!-- CONVÊNIO: fluxo progressivo -->
-                    <template v-if="billingType === 'convenio'">
-                        <!-- PASSO 1 — Select do plano (sempre visível) -->
-                        <Select v-model="form.insurance_plan_id" :options="activePlans" optionLabel="name" optionValue="id" placeholder="Selecionar convênio..." showClear class="w-full mb-2" size="small" />
-
-                        <!-- PASSO 2 — Procedimento (visível quando plano selecionado) -->
-                        <template v-if="hasInsurance">
-                            <template v-if="planServices.length > 0">
-                                <label class="text-xs text-color-secondary mb-1 block">Procedimento</label>
-                                <Select
-                                    v-model="selectedPlanService"
-                                    :options="planServices"
-                                    optionLabel="name"
-                                    optionValue="id"
-                                    placeholder="Selecionar procedimento..."
-                                    showClear
-                                    class="w-full mb-2"
-                                    size="small"
-                                    @update:modelValue="onProcedureSelect"
-                                />
-                            </template>
-                            <div v-else class="flex items-center justify-between gap-2 mb-2 p-2 rounded-lg bg-surface-100">
-                                <span class="text-xs text-color-secondary">Este convênio não tem procedimentos cadastrados.</span>
-                                <Button label="Cadastrar" icon="pi pi-plus" size="small" severity="secondary" outlined class="rounded-full shrink-0 text-xs h-7" @click="goToConveniosConfig" />
-                            </div>
-
-                            <!-- PASSO 3 — Nº da Guia + Valor (visível após selecionar procedimento ou sem procedimentos) -->
-                            <template v-if="selectedPlanService != null || planServices.length === 0">
-                                <div class="flex gap-2">
-                                    <div class="flex-1">
-                                        <label class="text-xs text-color-secondary mb-1 block">Nº da Guia</label>
-                                        <InputText v-model="form.insurance_guide_number" placeholder="Ex: 123456789" class="w-full" size="small" />
-                                    </div>
-                                    <div class="flex-1">
-                                        <label class="text-xs text-color-secondary mb-1 block">Valor (R$)</label>
-                                        <InputNumber v-model="form.insurance_value" mode="currency" currency="BRL" locale="pt-BR" :readonly="planServices.length > 0 && selectedPlanService != null" class="w-full" size="small" />
-                                    </div>
-                                </div>
-                            </template>
-                        </template>
-                    </template>
-                </div>
-
-                <!-- ── RECORRÊNCIA (só sessão) ───────────────────── -->
-                <div v-if="isSessionEvent" class="side-card">
-                    <div class="mb-3">
-                        <!-- Lista de itens adicionados -->
-                        <div v-if="commitmentItems.length" class="commitment-items-list mb-2">
-                            <div v-for="(item, idx) in commitmentItems" :key="idx" class="commitment-item-row">
-                                <!-- linha 1: nome + remover -->
-                                <div class="commitment-item-header">
-                                    <span class="commitment-item-name">{{ item.service_name }}</span>
-                                    <Button icon="pi pi-times" size="small" severity="danger" text @click="removeItem(idx)" />
-                                </div>
-
-                                <!-- linha 2: qtd | preço unit (editável) | desconto % | desconto fixo | total -->
-                                <div class="commitment-item-controls">
-                                    <div class="commitment-item-field">
-                                        <label class="commitment-item-label">Qtd</label>
-                                        <InputNumber v-model="item.quantity" :min="1" :max="99" size="small" inputClass="w-12 text-center" @update:modelValue="onItemChange(item)" />
-                                    </div>
-                                    <div class="commitment-item-field">
-                                        <label class="commitment-item-label">Preço unit.</label>
-                                        <InputNumber v-model="item.unit_price" mode="currency" currency="BRL" locale="pt-BR" :min="0" :minFractionDigits="2" size="small" inputClass="w-24" @update:modelValue="onItemChange(item)" />
-                                    </div>
-                                    <div class="commitment-item-field">
-                                        <label class="commitment-item-label">Desc %</label>
-                                        <InputNumber v-model="item.discount_pct" :min="0" :max="100" suffix="%" size="small" inputClass="w-16 text-center" @update:modelValue="onItemChange(item)" />
-                                    </div>
-                                    <div class="commitment-item-field">
-                                        <label class="commitment-item-label">Desc R$</label>
-                                        <InputNumber v-model="item.discount_flat" mode="currency" currency="BRL" locale="pt-BR" :min="0" :minFractionDigits="2" size="small" inputClass="w-20" @update:modelValue="onItemChange(item)" />
-                                    </div>
-                                    <div class="commitment-item-field commitment-item-field--final">
-                                        <label class="commitment-item-label">Total</label>
-                                        <span class="commitment-item-price">{{ fmtBRL(item.final_price) }}</span>
-                                    </div>
-                                </div>
-                            </div>
-
-                            <div class="commitment-items-total">
-                                <span class="text-sm text-color-secondary">Total da sessão</span>
-                                <span class="font-semibold">{{ fmtBRL(totalFromItems) }}</span>
-                            </div>
-                        </div>
-                    </div>
-
-                    <!-- Observação -->
-                    <div class="mb-3">
-                        <FloatLabel variant="on">
-                            <Textarea id="aed-observacoes-side" v-model="form.observacoes" class="w-full" variant="filled" rows="3" autoResize :disabled="isArchivedPastEdit" />
-                            <label for="aed-observacoes-side">Observação</label>
-                        </FloatLabel>
-                    </div>
-
-                    <!-- ── COBRANÇA DA SESSÃO ──────────────────────────── -->
-                    <AgendaEventoFinanceiroPanel v-if="isSessionEvent && isEdit && eventRow?.id" :evento="eventRow" class="mb-3" />
-
-                    <!-- Opção de recorrência para sessão SEM série (criação ou avulsa) -->
-                    <template v-if="!hasSerie">
-                        <div class="side-card__title mb-2">Frequência</div>
-                        <Message v-if="isSessionEvent && form.paciente_id && !agendaPerms.canCreateRecurrence" severity="warn" class="mb-3" :closable="false">
-                            <i class="pi pi-ban mr-1" />
-                            <b>{{ form.paciente_status === 'Arquivado' ? 'Paciente arquivado.' : 'Paciente inativo.' }}</b>
-                            Criação de recorrências está bloqueada.
-                        </Message>
-
-                        <!-- Data de início (= form.dia) com botão Hoje -->
-                        <div class="rec-startdate-row mb-3">
-                            <div class="flex items-center gap-1.5 min-w-0">
-                                <i class="pi pi-calendar text-primary-500 shrink-0" />
-                                <span class="text-sm font-medium truncate">{{ form.dia ? fmtDateBR(form.dia) : 'Selecione a data' }}</span>
-                            </div>
-                            <Button label="Hoje" size="small" severity="secondary" outlined class="rounded-full shrink-0" @click="setHoje" />
-                        </div>
-
-                        <!-- Chips de frequência -->
-                        <div class="freq-chips mb-3">
-                            <button
-                                v-for="f in freqOpcoes"
-                                :key="f.value"
-                                class="freq-chip"
-                                :class="{
-                                    'freq-chip--active': recorrenciaType === f.value,
-                                    'opacity-40 cursor-not-allowed': f.value !== 'avulsa' && !agendaPerms.canCreateRecurrence
-                                }"
-                                :disabled="f.value !== 'avulsa' && !agendaPerms.canCreateRecurrence"
-                                @click="!agendaPerms.canCreateRecurrence && f.value !== 'avulsa' ? null : (recorrenciaType = f.value)"
-                            >
-                                {{ f.label }}
-                            </button>
-                        </div>
-
-                        <!-- Info semanal/quinzenal -->
-                        <div v-if="recorrenciaType === 'semanal' || recorrenciaType === 'quinzenal'" class="recorrencia-preview mb-3">
-                            <i class="pi pi-refresh text-primary-500" />
-                            <span class="text-sm font-medium">
-                                {{ recorrenciaType === 'quinzenal' ? 'A cada 2 semanas, toda' : 'Toda' }}
-                                {{ nomeDiaSemana(diaSemanaRecorrencia) }}, às {{ form.startTime || '—' }}
-                            </span>
-                        </div>
-
-                        <!-- Seletor de dias da semana (diasEspecificos) -->
-                        <div v-if="recorrenciaType === 'diasEspecificos'" class="mb-3">
-                            <label class="block text-xs font-semibold text-color-secondary mb-1.5">Dias da semana</label>
-                            <div class="dias-semana-grid">
-                                <button v-for="d in diasSemanaOpcoes" :key="d.value" class="dia-chip" :class="{ 'dia-chip--active': diasSelecionados.includes(d.value) }" @click="toggleDiaSelecionado(d.value)">{{ d.short }}</button>
-                            </div>
-                        </div>
-
-                        <!-- Quantidade de sessões (apenas quando não é avulsa) -->
-                        <div v-if="recorrenciaType !== 'avulsa'" class="mb-3">
-                            <label class="block text-xs font-semibold text-color-secondary mb-1.5">Quantidade de sessões</label>
-                            <div class="flex gap-1.5 flex-wrap">
-                                <button v-for="opt in qtdSessoesOpcoes" :key="opt.value" class="freq-tab" :class="{ 'freq-tab--active': qtdSessoesMode === opt.value }" @click="qtdSessoesMode = opt.value">{{ opt.label }}</button>
-                            </div>
-                            <div v-if="qtdSessoesMode === 'personalizar'" class="personalizar-box mt-2">
-                                <InputNumber v-model="qtdSessoesCustom" :min="1" :max="200" showButtons buttonLayout="horizontal" fluid>
-                                    <template #decrementbuttonicon><i class="pi pi-minus" /></template>
-                                    <template #incrementbuttonicon><i class="pi pi-plus" /></template>
-                                </InputNumber>
-                            </div>
-                        </div>
-
-                        <!-- Preview das ocorrências -->
-                        <div v-if="recorrenciaType !== 'avulsa' && ocorrenciasComConflito.length" class="ocorrencias-preview">
-                            <div class="ocorrencias-header">
-                                <span class="text-xs font-semibold text-color-secondary">{{ totalOcorrencias }} sessões previstas</span>
-                                <span v-if="totalConflitos > 0" class="ocorrencias-aviso">
-                                    <i class="pi pi-exclamation-triangle" />
-                                    {{ totalConflitos }} com conflito
-                                </span>
-                            </div>
-                            <div class="ocorrencias-scroll">
-                                <div
-                                    v-for="(o, i) in ocorrenciasComConflito"
-                                    :key="i"
-                                    class="ocorrencia-item"
-                                    :class="{
-                                        'ocorrencia-item--fora': o.conflict?.type === 'feriado' || o.conflict?.type === 'bloqueado',
-                                        'ocorrencia-item--warn': o.conflict?.type === 'folga' || o.conflict?.type === 'pausa'
-                                    }"
-                                >
-                                    <i
-                                        class="pi"
-                                        :class="{
-                                            'pi-circle-fill': !o.conflict,
-                                            'pi-exclamation-triangle': o.conflict?.type === 'folga' || o.conflict?.type === 'pausa',
-                                            'pi-ban': o.conflict?.type === 'feriado' || o.conflict?.type === 'bloqueado'
-                                        }"
-                                        style="font-size: 9px"
-                                    />
-                                    <span class="text-xs">{{ fmtDateBRLong(o.date) }}</span>
-                                    <span v-if="o.conflict" class="ocorrencia-conflict-label">{{ o.conflict.label }}</span>
-                                </div>
-                            </div>
-                            <Message v-if="totalConflitos > 0" severity="warn" class="mt-2" :closable="false">
-                                <span class="text-xs">{{ totalConflitos }} sessão(ões) com conflito serão marcadas automaticamente para ajuste.</span>
-                            </Message>
-                        </div>
-
-                        <!-- Modo de valor da série — informativo, só quando há serviços + recorrência -->
-                        <div v-if="recorrenciaType !== 'avulsa' && commitmentItems.length > 0" class="mb-1 mt-3">
-                            <label class="block text-xs font-semibold text-color-secondary mb-1.5">Como interpretar o valor</label>
-                            <SelectButton
-                                v-model="serieValorMode"
-                                :options="[
-                                    { label: 'Por sessão', value: 'multiplicar' },
-                                    { label: 'Pacote fechado', value: 'dividir' }
-                                ]"
-                                optionLabel="label"
-                                optionValue="value"
-                                size="small"
-                                class="w-full mb-2"
-                            />
-                            <Message v-if="serieValorAviso" severity="info" :closable="false">
-                                <span class="text-xs">{{ serieValorAviso }}</span>
-                            </Message>
-                        </div>
-                    </template>
-                </div>
-            </div>
-        </div>
-
-        <!-- ══════════════════════════════════════════════ -->
-        <!-- Patient Picker Dialog                          -->
-        <!-- ══════════════════════════════════════════════ -->
-        <Dialog v-model:visible="pacientePickerOpen" modal header="Selecionar paciente" :draggable="false" :style="{ width: '860px', maxWidth: '96vw' }" :breakpoints="{ '960px': '96vw', '640px': '98vw' }">
-            <div class="flex flex-col gap-3">
-                <div class="flex flex-wrap items-center gap-3">
-                    <div class="flex-1 min-w-[240px]">
-                        <FloatLabel variant="on">
-                            <IconField>
-                                <InputIcon class="pi pi-search" />
-                                <InputText id="aed-paciente-search" v-model="pacienteSearch" class="w-full" autocomplete="off" variant="filled" />
-                            </IconField>
-                            <label for="aed-paciente-search">Buscar por nome, e-mail ou telefone…</label>
-                        </FloatLabel>
-                    </div>
-                    <Button label="Recarregar" icon="pi pi-refresh" severity="secondary" outlined class="rounded-full" :loading="pacientesLoading" @click="loadPatients(true)" />
-                </div>
-
-                <Message v-if="pacientesError" severity="warn">{{ pacientesError }}</Message>
-                <div v-if="pacientesLoading" class="text-sm text-color-secondary">Carregando pacientes…</div>
-                <div v-else-if="filteredPatients.length === 0" class="text-sm text-color-secondary">Nenhum paciente encontrado.</div>
-
-                <div v-else class="patient-list">
-                    <button v-for="p in filteredPatients" :key="p.id" class="patient-item" @click="selectPaciente(p)">
-                        <Avatar v-if="p.avatar_url" :image="p.avatar_url" shape="circle" class="shrink-0" />
-                        <Avatar v-else :label="patientInitials(p.nome)" shape="circle" class="shrink-0" />
-                        <div class="min-w-0 flex-1">
-                            <div class="font-semibold truncate">{{ p.nome || 'Sem nome' }}</div>
-                            <div class="text-xs text-color-secondary truncate">
-                                <span v-if="p.email">{{ p.email }}</span>
-                                <span v-if="p.email && p.telefone"> • </span>
-                                <span v-if="p.telefone">{{ p.telefone }}</span>
-                            </div>
-                        </div>
-                        <div class="shrink-0 flex items-center gap-2">
-                            <Tag v-if="p.status" :value="String(p.status)" severity="secondary" />
-                            <Button icon="pi pi-check" class="rounded-full" size="small" />
-                        </div>
-                    </button>
-                </div>
-            </div>
-            <template #footer>
-                <Button label="Fechar" icon="pi pi-times" text @click="pacientePickerOpen = false" />
-            </template>
-        </Dialog>
-
-        <!-- ══════════════════════════════════════════════ -->
-        <!-- Time Picker Dialog                             -->
-        <!-- ══════════════════════════════════════════════ -->
-        <Dialog v-model:visible="timePickerOpen" modal header="Data e Horário" :draggable="false" :style="{ width: '560px', maxWidth: '96vw' }" :breakpoints="{ '640px': '98vw' }">
-            <div class="flex flex-col gap-4">
-                <!-- Data -->
-                <div>
-                    <label class="block text-sm font-medium mb-2">Data</label>
-                    <DatePicker v-model="form.dia" dateFormat="dd/mm/yy" showIcon fluid inline />
-                </div>
-
-                <!-- ── Horários disponíveis (presencial e online unificado) ──── -->
-                <div v-if="availableSlots.length">
-                    <!-- Info online: lista os slots pré-configurados e orienta o usuário -->
-                    <template v-if="form.modalidade === 'online'">
-                        <Message v-if="!onlineAtivo" severity="warn" :closable="false" class="mb-2"> Atendimento online não está ativado. Ative em <strong>Configurações → Online</strong>. </Message>
-                        <div v-else class="online-info-bar mb-2">
-                            <i class="pi pi-video shrink-0" />
-                            <span v-if="loadingOnlineSlots" class="opacity-60">Carregando horários online…</span>
-                            <span v-else-if="onlineSlots.length">
-                                Horários online configurados para hoje:
-                                <strong>{{ onlineSlots.map((s) => s.hhmm).join(', ') }}</strong>
-                                <span class="online-info-bar__hint"> — marcados com <span class="online-dot-inline">●</span></span>
-                            </span>
-                            <span v-else class="opacity-70"> Nenhum horário online configurado para este dia — você pode agendar em qualquer horário da sua jornada. </span>
-                        </div>
-                    </template>
-
-                    <!-- Header: rótulo + period chips (só períodos com slots) -->
-                    <div class="flex items-center justify-between mb-2">
-                        <label class="text-sm font-medium">Horários disponíveis</label>
-                        <div class="flex gap-1">
-                            <button v-for="p in activePeriodos" :key="p.label" class="periodo-chip" :class="{ 'periodo-chip--active': selectedPeriodo === p }" @click="selectedPeriodo = selectedPeriodo === p ? null : p">
-                                <i :class="`pi ${p.icon}`" />
-                                {{ p.label }}
-                            </button>
-                        </div>
-                    </div>
-
-                    <!-- Grid de pills -->
-                    <div class="slots-grid">
-                        <button
-                            v-for="s in filteredSlots"
-                            :key="s.hhmm"
-                            class="slot-pill"
-                            :class="{
-                                'slot-pill--busy': s.busy,
-                                'slot-pill--current': form.startTime === s.hhmm,
-                                'slot-pill--online-cfg': form.modalidade === 'online' && s.isOnlineConfigured
-                            }"
-                            :title="s.busy ? 'Horário ocupado' : form.modalidade === 'online' && s.isOnlineConfigured ? `${s.hhmm} – ${s.endHhmm} · horário online configurado` : `${s.hhmm} – ${s.endHhmm}`"
-                            @click="!s.busy && selectSlot(s.hhmm)"
-                        >
-                            {{ s.hhmm }}
-                            <span v-if="form.modalidade === 'online' && s.isOnlineConfigured" class="slot-online-dot" />
-                        </button>
-                    </div>
-                    <div v-if="filteredSlots.length === 0" class="text-xs opacity-50 mt-1">Nenhum horário disponível neste período.</div>
-                </div>
-                <div v-else-if="form.dia" class="text-xs opacity-50">Nenhum horário disponível para este dia (verifique a jornada nas configurações).</div>
-
-                <Divider class="my-1" />
-
-                <!-- Início + Duração -->
-                <div class="time-controls">
-                    <div class="time-picker-wrap">
-                        <label class="time-label">Início</label>
-                        <DatePicker v-model="startTimeDate" timeOnly hourFormat="24" :stepMinute="5" showIcon iconDisplay="input" fluid placeholder="HH:MM">
-                            <template #inputicon="slotProps">
-                                <i class="pi pi-clock" @click="slotProps.clickCallback" />
-                            </template>
-                        </DatePicker>
-                    </div>
-
-                    <div class="time-picker-wrap">
-                        <label class="time-label">Duração</label>
-                        <Select
-                            v-model="form.duracaoMin"
-                            :options="duracaoOptions"
-                            optionLabel="label"
-                            optionValue="value"
-                            optionGroupLabel="label"
-                            optionGroupChildren="items"
-                            variant="filled"
-                            class="w-full"
-                            :disabled="isDynamic && commitmentItems.length > 0"
-                        />
-                        <small v-if="isDynamic && commitmentItems.length > 0" class="text-color-secondary text-xs mt-1 block"> Calculado pelos serviços adicionados </small>
-                    </div>
-                </div>
-
-                <!-- Término em destaque -->
-                <div v-if="fimDateTime" class="time-fim-card">
-                    <div class="time-fim-card__label">
-                        <i class="pi pi-flag-fill" />
-                        Término
-                    </div>
-                    <div class="time-fim-card__value">{{ fmtTime(fimDateTime) }}</div>
-                </div>
-
-                <Message v-if="timeConflict" severity="warn" class="mt-2" :closable="false">
-                    <i class="pi pi-exclamation-triangle mr-1" />
-                    {{ timeConflict }}
-                </Message>
-            </div>
-            <template #footer>
-                <Button label="Confirmar" icon="pi pi-check" @click="timePickerOpen = false" />
-            </template>
-        </Dialog>
-
-        <!-- Footer -->
-        <template v-if="step === 2" #footer>
-            <div class="flex items-center justify-between gap-2">
-                <div class="flex items-center gap-2">
-                    <Button v-if="!isEdit && allowBack" label="Voltar" icon="pi pi-arrow-left" severity="secondary" outlined size="small" class="rounded-full" @click="goBack" />
-                    <Button v-if="isEdit && hasSerie" label="Encerrar série" icon="pi pi-trash" severity="danger" outlined size="small" class="rounded-full text-xs h-8" @click="onEncerrarSerie" />
-                    <Button v-if="isEdit && !hasSerie" icon="pi pi-trash" severity="danger" outlined size="small" class="rounded-full h-9 w-9" v-tooltip.bottom="'Remover'" @click="onDelete" />
-
-                    <!-- Lembrar paciente (WhatsApp on-demand) -->
-                    <Button
-                        v-if="isEdit && isSessionEvent && form.paciente_id"
-                        icon="pi pi-whatsapp"
-                        severity="success"
-                        outlined
-                        size="small"
-                        class="rounded-full h-9 w-9"
-                        v-tooltip.bottom="'Enviar lembrete WhatsApp agora'"
-                        :loading="sendingReminder"
-                        @click="onSendManualReminder"
-                    />
-
-                    <!-- Google Calendar link -->
-                    <a
-                        v-if="isEdit && googleCalendarUrl"
-                        :href="googleCalendarUrl"
-                        target="_blank"
-                        rel="noopener noreferrer"
-                        class="gcal-btn"
-                        v-tooltip.top="'Abre o Google Agenda com o compromisso pré-preenchido. Em breve: sincronização automática e bidirecional com sua conta Google.'"
-                    >
-                        <svg class="gcal-btn__icon" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-                            <rect x="3" y="4" width="18" height="18" rx="2" stroke="currentColor" stroke-width="1.7" />
-                            <path d="M3 9h18" stroke="currentColor" stroke-width="1.7" />
-                            <path d="M8 2v4M16 2v4" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" />
-                            <path d="M8 13h.01M12 13h.01M16 13h.01M8 17h.01M12 17h.01" stroke="currentColor" stroke-width="2" stroke-linecap="round" />
-                        </svg>
-                        <span>Google Agenda</span>
-                    </a>
-                </div>
-                <Button label="Salvar" icon="pi pi-check" size="small" class="rounded-full" :disabled="!canSave" @click="onSave" />
-            </div>
-        </template>
-
-        <!-- ══════════════════════════════════════════════ -->
-        <!-- Cadastro Rápido de Paciente                    -->
-        <!-- ══════════════════════════════════════════════ -->
-        <ComponentCadastroRapido
-            v-model="cadRapidoOpen"
-            title="Novo Paciente"
-            table-name="patients"
-            name-field="nome_completo"
-            email-field="email_principal"
-            phone-field="telefone"
-            :extra-payload="{ status: 'Ativo' }"
-            @created="onPatientCreatedRapido"
-        />
-    </Dialog>
-</template>
-
-<style scoped>
-.agenda-event-composer :deep(.p-dialog-content) {
-    padding: 0.75rem;
-}
-
-/* ── tag: remarcado (roxo — sem severity nativo no PrimeVue) ─ */
-:deep(.tag-remarcado) {
-    background: #a855f7 !important;
-    color: #fff !important;
-}
-
-/* ── header dot ─────────────────────────────────── */
-.header-dot {
-    width: 10px;
-    height: 10px;
-    border-radius: 50%;
-    background: var(--p-primary-500, #6366f1);
-    flex-shrink: 0;
-}
-
-/* ── step 1: commitment grid ────────────────────── */
-.commitment-grid {
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 0.75rem;
-}
-@media (max-width: 640px) {
-    .commitment-grid {
-        grid-template-columns: 1fr;
-    }
-}
-
-.commitment-card {
-    width: 100%;
-    text-align: left;
-    border: 1px solid var(--surface-border);
-    border-radius: 6px;
-    background: color-mix(in srgb, var(--surface-card), transparent 10%);
-    transition:
-        box-shadow 0.12s ease,
-        transform 0.12s ease,
-        border-color 0.12s;
-    overflow: hidden;
-}
-.commitment-card:hover {
-    box-shadow: 0 6px 20px rgba(0, 0, 0, 0.1);
-    transform: translateY(-2px);
-    border-color: color-mix(in srgb, var(--card-color, var(--p-primary-500)) 60%, transparent);
-}
-.commitment-card__inner {
-    display: flex;
-    align-items: flex-start;
-    gap: 0.85rem;
-    padding: 1rem;
-}
-.commitment-card__icon {
-    display: grid;
-    place-items: center;
-    width: 2.2rem;
-    height: 2.2rem;
-    border-radius: 0.75rem;
-    background: color-mix(in srgb, var(--p-primary-500) 12%, transparent);
-    color: var(--p-primary-500);
-    font-size: 1rem;
-    flex-shrink: 0;
-}
-.commitment-card--blocked {
-    opacity: 0.45;
-    cursor: not-allowed;
-    pointer-events: none;
-    border-color: color-mix(in srgb, var(--red-500) 40%, var(--surface-border));
-    background: color-mix(in srgb, var(--red-50, #fef2f2) 30%, var(--surface-card));
-}
-
-/* ── step 2: grid layout ────────────────────────── */
-.composer-grid {
-    display: grid;
-    grid-template-columns: 1.3fr 0.7fr;
-    gap: 1rem;
-    align-items: start;
-    margin-top: 2px;
-}
-@media (max-width: 960px) {
-    .composer-grid {
-        grid-template-columns: 1fr;
-    }
-}
-
-/* ── paciente hero ──────────────────────────────── */
-.patient-hero {
-    border: 1.5px solid var(--surface-border);
-    border-radius: 6px;
-    overflow: hidden;
-    background: color-mix(in srgb, var(--surface-card), transparent 10%);
-}
-.patient-hero__label {
-    display: flex;
-    align-items: center;
-    gap: 0.4rem;
-    padding: 0.4rem 0.6rem 0.4rem 0.9rem;
-    font-size: 0.7rem;
-    font-weight: 700;
-    letter-spacing: 0.06em;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-    border-bottom: 1px solid var(--surface-border);
-    background: color-mix(in srgb, var(--surface-ground), transparent 30%);
-}
-
-/* Modalidade dentro do card de paciente */
-.patient-hero__modalidade {
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    padding: 8px 12px 10px;
-    border-top: 1px solid var(--surface-border);
-}
-.patient-hero__mod-label {
-    font-size: 0.7rem;
-    font-weight: 700;
-    letter-spacing: 0.05em;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-    white-space: nowrap;
-}
-
-/* Card genérico para seções (data/horário, etc.) */
-.field-card {
-    border-radius: 6px;
-    border: 1px solid var(--surface-border);
-    background: var(--surface-card);
-    overflow: hidden;
-}
-.field-card__header {
-    display: flex;
-    align-items: center;
-    gap: 6px;
-    padding: 7px 12px;
-    font-size: 0.7rem;
-    font-weight: 700;
-    letter-spacing: 0.06em;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-    border-bottom: 1px solid var(--surface-border);
-    background: color-mix(in srgb, var(--surface-ground), transparent 30%);
-    cursor: pointer;
-}
-.field-card__body {
-    padding: 0;
-}
-.status-select-btn :deep(.p-selectbutton) {
-    display: flex;
-    width: 100%;
-}
-.status-select-btn :deep(.p-togglebutton) {
-    flex: 1;
-    justify-content: center;
-    border-radius: 0 !important;
-    border: none !important;
-    border-right: 1px solid var(--surface-border) !important;
-    padding: 0.65rem 0.5rem;
-}
-.status-select-btn :deep(.p-togglebutton:last-child) {
-    border-right: none !important;
-}
-.patient-hero__empty {
-    display: flex;
-    align-items: center;
-    gap: 0.85rem;
-    width: 100%;
-    padding: 0.9rem;
-    text-align: left;
-    cursor: pointer;
-    transition: background 0.1s;
-}
-.patient-hero__empty:hover {
-    background: color-mix(in srgb, var(--p-primary-500) 5%, transparent);
-}
-.patient-hero__empty-icon {
-    display: grid;
-    place-items: center;
-    width: 2.5rem;
-    height: 2.5rem;
-    border-radius: 50%;
-    flex-shrink: 0;
-    background: color-mix(in srgb, var(--p-primary-500) 12%, transparent);
-    color: var(--p-primary-500);
-    font-size: 1.1rem;
-}
-.patient-hero__selected {
-    display: flex;
-    align-items: center;
-    gap: 0.85rem;
-    padding: 0.75rem 0.9rem;
-}
-.patient-avatar-bg :deep(.p-avatar) {
-    background: color-mix(in srgb, var(--p-primary-500) 18%, transparent);
-    color: var(--p-primary-500);
-}
-
-/* ── time hero ──────────────────────────────────── */
-.time-hero {
-    display: flex;
-    align-items: stretch;
-    cursor: pointer;
-    transition:
-        border-color 0.12s,
-        box-shadow 0.12s;
-    background: color-mix(in srgb, var(--surface-card), transparent 10%);
-}
-.time-hero:hover {
-    border-color: var(--p-primary-400, #818cf8);
-    box-shadow: 0 2px 12px color-mix(in srgb, var(--p-primary-500) 15%, transparent);
-}
-.time-hero__block {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    gap: 0.2rem;
-    padding: 0.7rem 0.5rem;
-    min-width: 0;
-}
-.time-hero__label {
-    font-size: 0.65rem;
-    font-weight: 700;
-    letter-spacing: 0.06em;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-    white-space: nowrap;
-}
-.time-hero__value {
-    font-size: 0.92rem;
-    font-weight: 700;
-    color: var(--text-color);
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    max-width: 100%;
-}
-.time-hero__sep {
-    width: 1px;
-    background: var(--surface-border);
-    margin: 0.5rem 0;
-}
-.time-hero__edit {
-    display: flex;
-    align-items: center;
-    padding: 0 0.75rem;
-    color: var(--text-color-secondary);
-    opacity: 0.5;
-    font-size: 0.8rem;
-}
-
-/* ── fields grid ────────────────────────────────── */
-.fields-grid {
-    display: grid;
-    grid-template-columns: 1fr 1fr;
-    gap: 0.85rem;
-}
-.fields-grid .col-span-full {
-    grid-column: 1 / -1;
-}
-@media (max-width: 640px) {
-    .fields-grid {
-        grid-template-columns: 1fr;
-    }
-}
-
-/* ── side panel ─────────────────────────────────── */
-.composer-right {
-    position: sticky;
-    top: 0;
-}
-.side-card {
-    border: 1px solid var(--surface-border);
-    border-radius: 6px;
-    padding: 0.9rem 1rem;
-    background: color-mix(in srgb, var(--surface-card), transparent 10%);
-}
-.side-card__title {
-    font-size: 0.72rem;
-    font-weight: 700;
-    letter-spacing: 0.06em;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-    margin-bottom: 0.65rem;
-}
-
-/* resumo rows */
-.summary-row {
-    display: flex;
-    align-items: center;
-    gap: 0.55rem;
-    font-size: 0.82rem;
-    color: var(--text-color);
-    padding: 0.3rem 0;
-    border-bottom: 1px solid color-mix(in srgb, var(--surface-border), transparent 40%);
-}
-.summary-row:last-child {
-    border-bottom: none;
-}
-.summary-icon {
-    font-size: 0.8rem;
-    color: var(--text-color-secondary);
-    opacity: 0.7;
-    width: 1rem;
-    flex-shrink: 0;
-}
-
-/* commit badge */
-.commit-badge {
-    display: inline-flex;
-    align-items: center;
-    padding: 0.2rem 0.65rem;
-    border-radius: 999px;
-    font-size: 0.72rem;
-    font-weight: 700;
-    border: 1px solid transparent;
-    white-space: nowrap;
-}
-
-/* ── serie banner ───────────────────────────────── */
-.serie-banner {
-    border-radius: 6px;
-    padding: 0.75rem 0.9rem;
-    background: color-mix(in srgb, var(--blue-500, #3b82f6) 8%, var(--surface-card));
-    border: 1px solid color-mix(in srgb, var(--blue-400, #60a5fa) 30%, transparent);
-}
-.serie-banner__head {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    font-size: 0.82rem;
-    font-weight: 700;
-    color: var(--blue-600, #2563eb);
-}
-.serie-banner__detail {
-    font-size: 0.78rem;
-    color: var(--text-color-secondary);
-    margin-top: 0.25rem;
-}
-
-/* escopo de edição */
-.scope-option {
-    display: flex;
-    align-items: center;
-    gap: 0.55rem;
-    cursor: pointer;
-}
-
-/* ── freq tabs ──────────────────────────────────── */
-.freq-tab {
-    padding: 0.25rem 0.75rem;
-    border-radius: 999px;
-    font-size: 0.75rem;
-    font-weight: 600;
-    border: 1px solid var(--surface-border);
-    background: transparent;
-    color: var(--text-color-secondary);
-    cursor: pointer;
-    transition:
-        background 0.1s,
-        color 0.1s,
-        border-color 0.1s;
-}
-.freq-tab:hover {
-    border-color: var(--p-primary-400);
-    color: var(--p-primary-500);
-}
-.freq-tab--active {
-    background: var(--p-primary-500, #6366f1);
-    border-color: var(--p-primary-500, #6366f1);
-    color: #fff;
-}
-
-/* ── recorrência preview ────────────────────────── */
-.recorrencia-preview {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    padding: 0.5rem 0.75rem;
-    border-radius: 6px;
-    background: color-mix(in srgb, var(--p-primary-500) 8%, transparent);
-    border: 1px solid color-mix(in srgb, var(--p-primary-400) 25%, transparent);
-}
-
-/* ocorrências */
-.ocorrencias-preview {
-    border-top: 1px solid var(--surface-border);
-    padding-top: 0.65rem;
-    margin-top: 0.65rem;
-}
-.ocorrencias-header {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    margin-bottom: 0.5rem;
-}
-.ocorrencias-aviso {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.3rem;
-    font-size: 0.7rem;
-    font-weight: 600;
-    color: var(--orange-600, #ea580c);
-}
-.ocorrencias-scroll {
-    display: flex;
-    flex-direction: column;
-    gap: 0.2rem;
-    max-height: 300px;
-    overflow-y: auto;
-    padding-right: 0.2rem;
-}
-.ocorrencia-item {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    padding: 0.25rem 0.3rem;
-    border-radius: 0.4rem;
-    color: var(--text-color);
-    transition: background 0.1s;
-}
-.ocorrencia-item i {
-    color: var(--p-primary-400);
-    flex-shrink: 0;
-}
-.ocorrencia-item--fora {
-    background: color-mix(in srgb, var(--red-500) 8%, transparent);
-    color: var(--red-600, #dc2626);
-}
-.ocorrencia-item--fora i {
-    color: var(--red-400, #f87171);
-}
-.ocorrencia-fora-label {
-    margin-left: auto;
-    font-size: 0.65rem;
-    font-weight: 700;
-    color: var(--red-500, #ef4444);
-    white-space: nowrap;
-    flex-shrink: 0;
-}
-.ocorrencia-item--warn {
-    background: color-mix(in srgb, var(--orange-500) 8%, transparent);
-    color: var(--orange-700, #c2410c);
-}
-.ocorrencia-item--warn i {
-    color: var(--orange-400, #fb923c);
-}
-.ocorrencia-conflict-label {
-    margin-left: auto;
-    font-size: 0.65rem;
-    font-weight: 700;
-    color: inherit;
-    white-space: nowrap;
-    flex-shrink: 0;
-    opacity: 0.8;
-}
-
-/* ── time picker ────────────────────────────────── */
-.time-controls {
-    display: flex;
-    gap: 1rem;
-    align-items: flex-end;
-    flex-wrap: wrap;
-}
-.time-picker-wrap {
-    display: flex;
-    flex-direction: column;
-    gap: 0.35rem;
-    min-width: 120px;
-    flex: 1;
-}
-.time-label {
-    font-size: 0.75rem;
-    font-weight: 600;
-    color: var(--text-color-secondary);
-}
-.time-fim {
-    display: flex;
-    flex-direction: column;
-    gap: 0.35rem;
-    justify-content: flex-end;
-    padding-bottom: 0.45rem;
-}
-.time-fim-value {
-    font-size: 1rem;
-    font-weight: 700;
-    color: var(--text-color);
-    white-space: nowrap;
-}
-
-/* Término em destaque */
-.time-fim-card {
-    display: flex;
-    align-items: center;
-    gap: 12px;
-    padding: 10px 16px;
-    border-radius: 6px;
-    background: color-mix(in srgb, var(--primary-500, #6366f1) 8%, var(--surface-card));
-    border: 1px solid color-mix(in srgb, var(--primary-400, #818cf8) 25%, transparent);
-}
-.time-fim-card__label {
-    display: flex;
-    align-items: center;
-    gap: 6px;
-    font-size: 0.72rem;
-    font-weight: 700;
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-    color: var(--primary-500, #6366f1);
-    opacity: 0.75;
-}
-.time-fim-card__value {
-    font-size: 1.5rem;
-    font-weight: 800;
-    letter-spacing: -0.03em;
-    color: var(--primary-600, #4f46e5);
-    margin-left: auto;
-}
-
-/* Período filter chips */
-.periodo-chip {
-    display: inline-flex;
-    align-items: center;
-    gap: 4px;
-    padding: 3px 10px;
-    border-radius: 999px;
-    font-size: 0.72rem;
-    font-weight: 600;
-    border: 1px solid var(--surface-border);
-    background: var(--surface-card);
-    color: var(--text-color-secondary);
-    cursor: pointer;
-    transition:
-        background 0.12s,
-        color 0.12s;
-}
-.periodo-chip--active {
-    background: var(--primary-500, #6366f1);
-    color: #fff;
-    border-color: var(--primary-500, #6366f1);
-}
-
-/* Slots grid */
-.slots-grid {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 6px;
-    max-height: 140px;
-    overflow-y: auto;
-}
-
-.slot-pill {
-    padding: 4px 10px;
-    border-radius: 999px;
-    font-size: 0.75rem;
-    font-weight: 700;
-    border: 1px solid var(--surface-border);
-    background: var(--surface-card);
-    color: var(--text-color);
-    cursor: pointer;
-    transition:
-        background 0.1s,
-        color 0.1s;
-    letter-spacing: -0.01em;
-}
-.slot-pill:hover:not(.slot-pill--busy) {
-    background: var(--primary-100, #e0e7ff);
-    border-color: var(--primary-400, #818cf8);
-    color: var(--primary-700, #3730a3);
-}
-.slot-pill--current {
-    background: var(--primary-500, #6366f1) !important;
-    color: #fff !important;
-    border-color: var(--primary-500, #6366f1) !important;
-}
-.slot-pill--busy {
-    opacity: 0.4;
-    cursor: not-allowed;
-    text-decoration: line-through;
-}
-
-/* Online slots card */
-/* Info bar online (substitui o card separado) */
-.online-info-bar {
-    display: flex;
-    align-items: flex-start;
-    gap: 8px;
-    padding: 8px 12px;
-    border-radius: 0.75rem;
-    background: color-mix(in srgb, var(--blue-50, #eff6ff) 70%, var(--surface-card));
-    border: 1px solid color-mix(in srgb, var(--blue-300, #93c5fd) 35%, transparent);
-    font-size: 0.78rem;
-    color: var(--blue-800, #1e40af);
-}
-.online-info-bar .pi-video {
-    color: var(--blue-500, #3b82f6);
-    margin-top: 1px;
-}
-.online-info-bar__hint {
-    opacity: 0.7;
-}
-
-/* Dot inline para o texto de dica */
-.online-dot-inline {
-    display: inline-block;
-    width: 8px;
-    height: 8px;
-    border-radius: 50%;
-    background: var(--blue-500, #3b82f6);
-    vertical-align: middle;
-}
-
-/* Pill marcado como configurado para online */
-.slot-pill--online-cfg {
-    border-color: color-mix(in srgb, var(--blue-400, #60a5fa) 60%, transparent) !important;
-    background: color-mix(in srgb, var(--blue-50, #eff6ff) 80%, var(--surface-card)) !important;
-    color: var(--blue-700, #1d4ed8) !important;
-}
-.slot-pill--online-cfg:hover:not(.slot-pill--busy) {
-    background: var(--blue-100, #dbeafe) !important;
-}
-
-/* Dot azul dentro do pill quando é slot online configurado */
-.slot-online-dot {
-    display: inline-block;
-    width: 5px;
-    height: 5px;
-    border-radius: 50%;
-    background: var(--blue-500, #3b82f6);
-    margin-left: 3px;
-    vertical-align: middle;
-    flex-shrink: 0;
-}
-
-/* ── rec startdate row ──────────────────────────── */
-.rec-startdate-row {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    gap: 0.5rem;
-    padding: 0.45rem 0.65rem;
-    border-radius: 6px;
-    background: color-mix(in srgb, var(--surface-ground), transparent 30%);
-    border: 1px solid var(--surface-border);
-}
-
-/* ── freq chips (frequência principal) ──────────── */
-.freq-chips {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.4rem;
-}
-.freq-chip {
-    padding: 0.3rem 0.7rem;
-    border-radius: 999px;
-    font-size: 0.75rem;
-    font-weight: 600;
-    border: 1px solid var(--surface-border);
-    background: transparent;
-    color: var(--text-color-secondary);
-    cursor: pointer;
-    transition:
-        background 0.1s,
-        color 0.1s,
-        border-color 0.1s;
-    white-space: nowrap;
-}
-.freq-chip:hover {
-    border-color: var(--p-primary-400);
-    color: var(--p-primary-500);
-}
-.freq-chip--active {
-    background: var(--p-primary-500, #6366f1);
-    border-color: var(--p-primary-500, #6366f1);
-    color: #fff;
-}
-
-/* ── dias da semana grid ────────────────────────── */
-.dias-semana-grid {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.35rem;
-}
-.dia-chip {
-    padding: 0.3rem 0.6rem;
-    border-radius: 999px;
-    font-size: 0.75rem;
-    font-weight: 700;
-    border: 1px solid var(--surface-border);
-    background: transparent;
-    color: var(--text-color-secondary);
-    cursor: pointer;
-    transition:
-        background 0.1s,
-        color 0.1s,
-        border-color 0.1s;
-    min-width: 2.6rem;
-    text-align: center;
-}
-.dia-chip:hover {
-    border-color: var(--p-primary-400);
-    color: var(--p-primary-500);
-}
-.dia-chip--active {
-    background: var(--p-primary-500, #6366f1);
-    border-color: var(--p-primary-500, #6366f1);
-    color: #fff;
-}
-
-/* ── personalizar box ───────────────────────────── */
-.personalizar-box {
-    border: 1px solid var(--surface-border);
-    border-radius: 6px;
-    padding: 0.75rem;
-    background: color-mix(in srgb, var(--surface-ground), transparent 40%);
-    display: flex;
-    flex-direction: column;
-    gap: 0.65rem;
-}
-
-/* ── patient list ───────────────────────────────── */
-.patient-list {
-    display: flex;
-    flex-direction: column;
-    gap: 0.6rem;
-    max-height: 56vh;
-    overflow: auto;
-    padding-right: 0.25rem;
-}
-.patient-item {
-    width: 100%;
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    gap: 1rem;
-    text-align: left;
-    padding: 0.85rem 0.95rem;
-    border: 1px solid var(--surface-border);
-    border-radius: 6px;
-    background: color-mix(in srgb, var(--surface-card), transparent 10%);
-    transition:
-        box-shadow 0.12s ease,
-        transform 0.12s ease;
-}
-.patient-item:hover {
-    box-shadow: 0 6px 18px rgba(0, 0, 0, 0.06);
-    transform: translateY(-1px);
-}
-
-/* ── serie panel (Recorrências Aplicadas) ─────────── */
-.serie-panel {
-    border: 1px solid var(--surface-border);
-    border-radius: 6px;
-    overflow: hidden;
-}
-.serie-panel__header {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    padding: 0.5rem 0.9rem;
-    font-size: 0.7rem;
-    font-weight: 700;
-    letter-spacing: 0.06em;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-    background: color-mix(in srgb, var(--surface-ground), transparent 20%);
-    border-bottom: 1px solid var(--surface-border);
-}
-.serie-panel__stats {
-    display: flex;
-    gap: 0.3rem;
-    font-size: 0.7rem;
-    font-weight: 400;
-    text-transform: none;
-    letter-spacing: 0;
-    opacity: 0.75;
-    margin-left: 0.25rem;
-}
-.serie-panel__empty {
-    padding: 0.85rem;
-    font-size: 0.82rem;
-    color: var(--text-color-secondary);
-    text-align: center;
-}
-.serie-pills-wrap {
-    display: flex;
-    flex-direction: column;
-    max-height: 340px;
-    overflow-y: auto;
-}
-.serie-pill {
-    display: flex;
-    align-items: center;
-    gap: 0.6rem;
-    padding: 0.4rem 0.9rem;
-    border-bottom: 1px solid color-mix(in srgb, var(--surface-border), transparent 55%);
-    transition: background 0.1s;
-    border-left: 3px solid transparent;
-}
-.serie-pill:last-child {
-    border-bottom: none;
-}
-.serie-pill:hover {
-    background: color-mix(in srgb, var(--surface-ground), transparent 10%);
-}
-.serie-pill--current {
-    background: color-mix(in srgb, var(--p-primary-500) 7%, transparent);
-    border-left-color: var(--p-primary-500);
-}
-.serie-pill--past {
-    opacity: 0.5;
-}
-.serie-pill--realizado {
-    border-left-color: var(--green-400, #4ade80);
-}
-.serie-pill--faltou {
-    border-left-color: var(--red-400, #f87171);
-}
-.serie-pill--cancelado {
-    border-left-color: var(--surface-border);
-}
-.serie-pill--remarcado {
-    border-left-color: var(--orange-400, #fb923c);
-}
-.serie-pill__date {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    min-width: 2.5rem;
-    flex-shrink: 0;
-    line-height: 1.15;
-}
-.serie-pill__weekday {
-    font-size: 0.58rem;
-    font-weight: 700;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-    letter-spacing: 0.04em;
-}
-.serie-pill__daynum {
-    font-size: 1rem;
-    font-weight: 800;
-    color: var(--text-color);
-}
-.serie-pill__month {
-    font-size: 0.58rem;
-    font-weight: 600;
-    text-transform: uppercase;
-    color: var(--text-color-secondary);
-}
-.serie-pill__time {
-    font-size: 0.72rem;
-    color: var(--text-color-secondary);
-    flex-shrink: 0;
-    min-width: 2.8rem;
-}
-.serie-pill__status-sel {
-    flex: 1;
-    min-width: 0;
-    max-width: 125px;
-}
-.serie-pill__cur-badge {
-    font-size: 0.58rem;
-    font-weight: 700;
-    text-transform: uppercase;
-    letter-spacing: 0.06em;
-    color: var(--p-primary-500);
-    background: color-mix(in srgb, var(--p-primary-500) 12%, transparent);
-    border: 1px solid color-mix(in srgb, var(--p-primary-500) 30%, transparent);
-    border-radius: 999px;
-    padding: 0.1rem 0.45rem;
-    flex-shrink: 0;
-    white-space: nowrap;
-}
-.serie-pill__del {
-    flex-shrink: 0;
-    width: 2rem;
-}
-
-/* ── Commitment items (serviços vinculados ao evento) ── */
-.commitment-items-list {
-    display: flex;
-    flex-direction: column;
-    gap: 0.35rem;
-    border: 1px solid var(--surface-border);
-    border-radius: 6px;
-    padding: 0.5rem;
-}
-.commitment-item-row {
-    margin-bottom: 4px;
-}
-.commitment-item-header {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    margin-bottom: 4px;
-}
-.commitment-item-name {
-    flex: 1;
-    font-size: 0.85rem;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-}
-.commitment-item-controls {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 8px;
-    align-items: flex-end;
-    padding-bottom: 8px;
-    border-bottom: 1px solid var(--p-content-border-color);
-    margin-bottom: 8px;
-}
-.commitment-item-field {
-    display: flex;
-    flex-direction: column;
-    gap: 2px;
-}
-.commitment-item-field--final {
-    margin-left: auto;
-}
-.commitment-item-label {
-    font-size: 0.65rem;
-    color: var(--p-text-muted-color);
-    font-weight: 500;
-    text-transform: uppercase;
-    letter-spacing: 0.03em;
-}
-.commitment-item-price {
-    font-size: 0.85rem;
-    font-weight: 600;
-    white-space: nowrap;
-    min-width: 5rem;
-    text-align: right;
-}
-.commitment-items-total {
-    display: flex;
-    justify-content: space-between;
-    padding-top: 0.35rem;
-    margin-top: 0.25rem;
-    border-top: 1px solid var(--surface-border);
-}
-
-/* ── Google Calendar button ─────────────────────── */
-.gcal-btn {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.45rem;
-    padding: 0.45rem 0.9rem;
-    border-radius: 6px;
-    border: 1px solid #4285f4;
-    background: transparent;
-    color: #4285f4;
-    font-size: 0.85rem;
-    font-weight: 500;
-    text-decoration: none;
-    transition:
-        background 0.15s ease,
-        color 0.15s ease;
-    cursor: pointer;
-    white-space: nowrap;
-}
-.gcal-btn:hover {
-    background: #4285f4;
-    color: #fff;
-}
-.gcal-btn__icon {
-    width: 16px;
-    height: 16px;
-    flex-shrink: 0;
-}
-</style>