diff --git a/src/features/patients/cadastro/recebidos/CadastrosRecebidosPage.vue b/src/features/patients/cadastro/recebidos/CadastrosRecebidosPage.vue
index b50700e..080050a 100644
--- a/src/features/patients/cadastro/recebidos/CadastrosRecebidosPage.vue
+++ b/src/features/patients/cadastro/recebidos/CadastrosRecebidosPage.vue
@@ -17,6 +17,9 @@
 <script setup>
 import { supabase } from '@/lib/supabase/client';
 import { useTenantStore } from '@/stores/tenantStore';
+// Fase 2 (Graphify hotspot): convertToPatient duplicado em 2 pages — INSERT/UPDATE
+// extraídos pro repository pra remover duplicação.
+import { createPatient, markIntakeConverted } from '@/features/patients/services/patientsRepository';
 import { logError } from '@/support/supportLogger';
 import { useConfirm } from 'primevue/useconfirm';
 import { useToast } from 'primevue/usetoast';
@@ -402,13 +405,13 @@ async function convertToPatient() {
             if (patientPayload[k] === undefined) delete patientPayload[k];
         });
 
-        const { data: created, error: insErr } = await supabase.from('patients').insert(patientPayload).select('id').single();
-        if (insErr) throw insErr;
+        // Repository chamadas (Fase 2 — convertToPatient de-dup).
+        // patientsRepository.createPatient strip owner_id do payload + sempre injeta auth.uid().
+        const created = await createPatient(patientPayload);
         const patientId = created?.id;
         if (!patientId) throw new Error('Falha ao obter ID do paciente criado.');
 
-        const { error: upErr } = await supabase.from('patient_intake_requests').update({ status: 'converted', converted_patient_id: patientId, updated_at: new Date().toISOString() }).eq('id', item.id);
-        if (upErr) throw upErr;
+        await markIntakeConverted(item.id, patientId);
 
         toast.add({ severity: 'success', summary: 'Convertido', detail: 'Cadastro convertido em paciente.', life: 2500 });
         dlg.value.open = false;
diff --git a/src/features/patients/composables/usePatientDetail.js b/src/features/patients/composables/usePatientDetail.js
index 4fee06f..92c8215 100644
--- a/src/features/patients/composables/usePatientDetail.js
+++ b/src/features/patients/composables/usePatientDetail.js
@@ -4,62 +4,18 @@
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatientDetail.js
 |
-| Composable de detalhe completo de paciente — patient row + grupos + tags
-| Extraido do PatientProntuario.vue pra permitir reuso em MelissaPaciente.vue.
-| Mantem a mesma logica original (Promise.all em 2 etapas, RLS-aware).
+| Detalhe completo de paciente — patient row + grupos + tags. Extraido do
+| PatientProntuario.vue pra permitir reuso em MelissaPaciente.vue.
+| Mantem a mesma logica (Promise.all em 2 etapas) — agora via repository.
 |--------------------------------------------------------------------------
 */
 import { ref } from 'vue';
-import { supabase } from '@/lib/supabase/client';
-
-async function getPatientById(id) {
-    const { data, error } = await supabase
-        .from('patients')
-        .select('*')
-        .eq('id', id)
-        .maybeSingle();
-    if (error) throw error;
-    return data;
-}
-
-async function getPatientRelations(id) {
-    const { data: g, error: ge } = await supabase
-        .from('patient_group_patient')
-        .select('patient_group_id')
-        .eq('patient_id', id);
-    if (ge) throw ge;
-    const { data: t, error: te } = await supabase
-        .from('patient_patient_tag')
-        .select('tag_id')
-        .eq('patient_id', id);
-    if (te) throw te;
-    return {
-        groupIds: (g || []).map((x) => x.patient_group_id).filter(Boolean),
-        tagIds: (t || []).map((x) => x.tag_id).filter(Boolean)
-    };
-}
-
-async function getGroupsByIds(ids) {
-    if (!ids?.length) return [];
-    const { data, error } = await supabase
-        .from('patient_groups')
-        .select('id, nome')
-        .in('id', ids)
-        .order('nome', { ascending: true });
-    if (error) throw error;
-    return (data || []).map((g) => ({ id: g.id, name: g.nome }));
-}
-
-async function getTagsByIds(ids) {
-    if (!ids?.length) return [];
-    const { data, error } = await supabase
-        .from('patient_tags')
-        .select('id, nome, cor')
-        .in('id', ids)
-        .order('nome', { ascending: true });
-    if (error) throw error;
-    return (data || []).map((t) => ({ id: t.id, name: t.nome, color: t.cor }));
-}
+import {
+    getPatientById,
+    getPatientRelations,
+    getGroupsByIds,
+    getTagsByIds
+} from '@/features/patients/services/patientsRepository';
 
 export function usePatientDetail() {
     const patient = ref(null);
diff --git a/src/features/patients/composables/usePatientDocuments.js b/src/features/patients/composables/usePatientDocuments.js
index 795de83..b6322b7 100644
--- a/src/features/patients/composables/usePatientDocuments.js
+++ b/src/features/patients/composables/usePatientDocuments.js
@@ -4,13 +4,14 @@
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatientDocuments.js
 |
-| Documentos do paciente — carrega so os campos pra KPIs (count, tipo,
-| ultima atualizacao). O detalhe completo fica em DocumentsListPage que
-| tem composable proprio. Filtra deletados (deleted_at IS NULL).
+| Documentos do paciente — campos pra KPIs (count, tipo, última atualização).
+| O detalhe completo fica em DocumentsListPage. Filtra deletados.
+|
+| I/O delegada ao patientsRepository.
 |--------------------------------------------------------------------------
 */
 import { ref, computed } from 'vue';
-import { supabase } from '@/lib/supabase/client';
+import { listDocumentsByPatient } from '@/features/patients/services/patientsRepository';
 import { fmtSize, DOC_TYPE_LABEL } from '@/features/patients/utils/patientFormatters';
 
 export function usePatientDocuments() {
@@ -27,15 +28,7 @@ export function usePatientDocuments() {
         error.value = '';
         documents.value = [];
         try {
-            const { data, error: err } = await supabase
-                .from('documents')
-                .select('id, tipo_documento, created_at, status_revisao, tamanho_bytes')
-                .eq('patient_id', patientId)
-                .is('deleted_at', null)
-                .order('created_at', { ascending: false })
-                .limit(200);
-            if (err) throw err;
-            documents.value = data || [];
+            documents.value = await listDocumentsByPatient(patientId);
         } catch (e) {
             error.value = e?.message || 'Falha ao carregar documentos.';
             documents.value = [];
@@ -45,9 +38,7 @@ export function usePatientDocuments() {
     }
 
     const total = computed(() => documents.value.length);
-    const totalBytes = computed(() =>
-        documents.value.reduce((acc, d) => acc + Number(d.tamanho_bytes || 0), 0)
-    );
+    const totalBytes = computed(() => documents.value.reduce((acc, d) => acc + Number(d.tamanho_bytes || 0), 0));
     const tiposCount = computed(() => {
         const map = new Map();
         documents.value.forEach((d) => {
@@ -58,10 +49,6 @@ export function usePatientDocuments() {
     });
     const ultimo = computed(() => documents.value[0] || null);
 
-    /**
-     * Tipo de documento mais comum (alimenta KPI "Mais comum").
-     * Retorna { tipo, count, label } ou null se vazio.
-     */
     const topType = computed(() => {
         const por = {};
         for (const d of documents.value) {
@@ -74,16 +61,8 @@ export function usePatientDocuments() {
         return { tipo, count, label: DOC_TYPE_LABEL[tipo] || tipo };
     });
 
-    /**
-     * Count de documentos com status_revisao === 'pendente'.
-     */
-    const pendentes = computed(() =>
-        documents.value.filter((d) => d.status_revisao === 'pendente').length
-    );
+    const pendentes = computed(() => documents.value.filter((d) => d.status_revisao === 'pendente').length);
 
-    /**
-     * Tamanho total formatado em string legivel (B/KB/MB/GB).
-     */
     const sizeTotalFormatted = computed(() => fmtSize(totalBytes.value));
 
     return {
diff --git a/src/features/patients/composables/usePatientFinancial.js b/src/features/patients/composables/usePatientFinancial.js
index f29ceb5..0380ef5 100644
--- a/src/features/patients/composables/usePatientFinancial.js
+++ b/src/features/patients/composables/usePatientFinancial.js
@@ -4,20 +4,26 @@
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatientFinancial.js
 |
-| Lancamentos financeiros (financial_records) do paciente. Filtra type=receita,
-| limita 100. Schema: paid_at NULL = pendente, preenchido = pago.
+| Lançamentos financeiros (financial_records) do paciente. type=receita,
+| limit 100. paid_at NULL = pendente, preenchido = pago.
 | "Vencido" = paid_at IS NULL AND due_date < hoje.
-| Computeds derivados: kpis (em aberto, atrasado, total, ultimo pago).
+| Computeds: kpis (em aberto, atrasado, total, último pago, status financeiro).
 |--------------------------------------------------------------------------
 */
 import { ref, computed } from 'vue';
-import { supabase } from '@/lib/supabase/client';
+import {
+    listFinancialRecordsByPatient,
+    createFinancialRecord,
+    markFinancialRecordPaid,
+    markFinancialRecordUnpaid
+} from '@/features/patients/services/patientsRepository';
 
 export function usePatientFinancial() {
     const records = ref([]);
     const loading = ref(false);
     const error = ref('');
     const busy = ref(false);
+    // Dentro da function — não vaza entre instâncias (audit alta resolvida)
     let _lastPatientId = null;
 
     async function load(patientId) {
@@ -30,15 +36,7 @@ export function usePatientFinancial() {
         error.value = '';
         records.value = [];
         try {
-            const { data, error: err } = await supabase
-                .from('financial_records')
-                .select('id, type, amount, due_date, paid_at, description, payment_method, category, created_at')
-                .eq('patient_id', patientId)
-                .eq('type', 'receita')
-                .order('created_at', { ascending: false })
-                .limit(100);
-            if (err) throw err;
-            records.value = data || [];
+            records.value = await listFinancialRecordsByPatient(patientId);
         } catch (e) {
             error.value = e?.message || 'Falha ao carregar lançamentos.';
             records.value = [];
@@ -73,11 +71,7 @@ export function usePatientFinancial() {
     });
 
     /**
-     * Status financeiro detalhado pra KPI da Visao Geral.
-     * - emDia: nenhum pendente vencido (paid_at NULL && due_date < hoje)
-     * - proxVenc: proximo pendente com due_date no futuro
-     * - totalPendente / totalPago: somatorio
-     * - vencidos: count de pendentes vencidos
+     * Status financeiro detalhado pra KPI da Visão Geral.
      */
     const statusFinanceiro = computed(() => {
         const recs = records.value;
@@ -90,9 +84,10 @@ export function usePatientFinancial() {
         const vencidos = pendentes.filter(
             (r) => r.due_date && new Date(r.due_date + 'T23:59:59').getTime() < now
         );
-        const proxVenc = pendentes
-            .filter((r) => r.due_date && new Date(r.due_date + 'T00:00:00').getTime() >= now)
-            .sort((a, b) => new Date(a.due_date) - new Date(b.due_date))[0] || null;
+        const proxVenc =
+            pendentes
+                .filter((r) => r.due_date && new Date(r.due_date + 'T00:00:00').getTime() >= now)
+                .sort((a, b) => new Date(a.due_date) - new Date(b.due_date))[0] || null;
         const totalPendente = pendentes.reduce((acc, r) => acc + (Number(r.amount) || 0), 0);
         const totalPago = pagos.reduce((acc, r) => acc + (Number(r.amount) || 0), 0);
         return {
@@ -104,10 +99,6 @@ export function usePatientFinancial() {
         };
     });
 
-    /**
-     * Lancamentos ordenados DESC por due_date (fallback created_at).
-     * Mais recente primeiro pra alimentar a tabela da Tab Financeiro.
-     */
     const recordsOrdenados = computed(() =>
         [...records.value].sort((a, b) => {
             const da = a.due_date || a.created_at;
@@ -116,19 +107,11 @@ export function usePatientFinancial() {
         })
     );
 
-    /**
-     * Marca um lancamento como pago (paid_at = now). Auto-reload.
-     * Retorna {ok, error?}.
-     */
     async function markPaid(recordId) {
         if (!recordId || busy.value) return { ok: false, error: 'busy' };
         busy.value = true;
         try {
-            const { error: err } = await supabase
-                .from('financial_records')
-                .update({ paid_at: new Date().toISOString() })
-                .eq('id', recordId);
-            if (err) throw err;
+            await markFinancialRecordPaid(recordId);
             if (_lastPatientId) await load(_lastPatientId);
             return { ok: true };
         } catch (e) {
@@ -138,49 +121,14 @@ export function usePatientFinancial() {
         }
     }
 
-    /**
-     * Cria um novo lancamento manual (type=receita) pro paciente.
-     * Insere com tenant_id + owner_id resolvidos via auth/tenant store.
-     * Auto-reload ao final pra refletir nos KPIs e tabela.
-     *
-     * payload: { description, amount, due_date, payment_method? }
-     * Retorna {ok, data?, error?}.
-     */
     async function createRecord(patientId, payload = {}) {
         if (!patientId || busy.value) return { ok: false, error: 'busy' };
         if (!payload?.amount || Number.isNaN(Number(payload.amount))) {
-            return { ok: false, error: 'Valor invalido' };
+            return { ok: false, error: 'Valor inválido' };
         }
         busy.value = true;
         try {
-            const { data: userData } = await supabase.auth.getUser();
-            const ownerId = userData?.user?.id;
-            // tenant_id: tenta tenantStore lazy import, fallback null (RLS
-            // via owner_id ainda permite insert).
-            let tenantId = null;
-            try {
-                const { useTenantStore } = await import('@/stores/tenantStore');
-                tenantId = useTenantStore().activeTenantId || null;
-            } catch { /* sem tenant store — segue */ }
-
-            const row = {
-                patient_id: patientId,
-                owner_id: ownerId,
-                tenant_id: tenantId,
-                type: 'receita',
-                amount: Number(payload.amount),
-                due_date: payload.due_date || null,
-                description: String(payload.description || '').trim() || null,
-                payment_method: payload.payment_method || null,
-                paid_at: null
-            };
-
-            const { data, error: err } = await supabase
-                .from('financial_records')
-                .insert([row])
-                .select()
-                .single();
-            if (err) throw err;
+            const data = await createFinancialRecord(patientId, payload);
             if (_lastPatientId) await load(_lastPatientId);
             return { ok: true, data };
         } catch (e) {
@@ -190,18 +138,11 @@ export function usePatientFinancial() {
         }
     }
 
-    /**
-     * Reverte: remove paid_at (volta pra pendente). Auto-reload.
-     */
     async function markUnpaid(recordId) {
         if (!recordId || busy.value) return { ok: false, error: 'busy' };
         busy.value = true;
         try {
-            const { error: err } = await supabase
-                .from('financial_records')
-                .update({ paid_at: null })
-                .eq('id', recordId);
-            if (err) throw err;
+            await markFinancialRecordUnpaid(recordId);
             if (_lastPatientId) await load(_lastPatientId);
             return { ok: true };
         } catch (e) {
diff --git a/src/features/patients/composables/usePatientMessages.js b/src/features/patients/composables/usePatientMessages.js
index 88fb189..29c5882 100644
--- a/src/features/patients/composables/usePatientMessages.js
+++ b/src/features/patients/composables/usePatientMessages.js
@@ -4,13 +4,15 @@
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatientMessages.js
 |
-| Mensagens de conversa do paciente. Carrega 200 mais recentes (in+out)
-| pra alimentar o card "Ultimas mensagens" (Visao Geral, top 4) e os
-| KPIs da aba Conversas. Conversa completa fica no PatientConversationsTab.
+| Mensagens de conversa do paciente. 200 mais recentes (in+out) pra alimentar
+| o card "Últimas mensagens" (top 4) e KPIs da aba Conversas.
+| Conversa completa fica no PatientConversationsTab.
+|
+| I/O delegada ao patientsRepository.
 |--------------------------------------------------------------------------
 */
 import { ref, computed } from 'vue';
-import { supabase } from '@/lib/supabase/client';
+import { listMessagesByPatient } from '@/features/patients/services/patientsRepository';
 
 export function usePatientMessages() {
     const messages = ref([]);
@@ -26,14 +28,7 @@ export function usePatientMessages() {
         error.value = '';
         messages.value = [];
         try {
-            const { data, error: err } = await supabase
-                .from('conversation_messages')
-                .select('id, body, direction, created_at, channel, kanban_status')
-                .eq('patient_id', patientId)
-                .order('created_at', { ascending: false })
-                .limit(200);
-            if (err) throw err;
-            messages.value = data || [];
+            messages.value = await listMessagesByPatient(patientId);
         } catch (e) {
             error.value = e?.message || 'Falha ao carregar mensagens.';
             messages.value = [];
@@ -43,18 +38,11 @@ export function usePatientMessages() {
     }
 
     const recentes = computed(() => messages.value.slice(0, 4));
-    const totalIn = computed(() =>
-        messages.value.filter((m) => m.direction === 'in' || m.direction === 'inbound').length
-    );
-    const totalOut = computed(() =>
-        messages.value.filter((m) => m.direction === 'out' || m.direction === 'outbound').length
-    );
+    const totalIn = computed(() => messages.value.filter((m) => m.direction === 'in' || m.direction === 'inbound').length);
+    const totalOut = computed(() => messages.value.filter((m) => m.direction === 'out' || m.direction === 'outbound').length);
     const ultimaMensagem = computed(() => messages.value[0] || null);
     const primeiraMensagem = computed(() => messages.value[messages.value.length - 1] || null);
 
-    /**
-     * Canais unicos usados nas mensagens (whatsapp, sms, email).
-     */
     const canais = computed(() => {
         const set = new Set();
         for (const m of messages.value) if (m.channel) set.add(m.channel);
diff --git a/src/features/patients/composables/usePatientRecurrences.js b/src/features/patients/composables/usePatientRecurrences.js
index 082a258..ebcccb4 100644
--- a/src/features/patients/composables/usePatientRecurrences.js
+++ b/src/features/patients/composables/usePatientRecurrences.js
@@ -4,15 +4,18 @@
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatientRecurrences.js
 |
-| Carrega regras de recorrencia (recurrence_rules) filtradas por paciente.
-| Usado pela Tab Agenda do MelissaPaciente pra mostrar "este paciente tem
-| sessao toda segunda 14h" e dar acoes inline (cancelar/reativar).
+| Regras de recorrência (recurrence_rules) do paciente. Usado pela Tab Agenda
+| do MelissaPaciente pra mostrar "este paciente tem sessão toda segunda 14h"
+| e ações inline (cancelar/reativar).
 |
-| Mutations espelham o pattern de MelissaRecorrencias.vue.
+| I/O delegada ao patientsRepository.
 |--------------------------------------------------------------------------
 */
 import { ref, computed } from 'vue';
-import { supabase } from '@/lib/supabase/client';
+import {
+    listRecurrencesByPatient,
+    updateRecurrenceStatus
+} from '@/features/patients/services/patientsRepository';
 
 export function usePatientRecurrences() {
     const rules = ref([]);
@@ -31,15 +34,9 @@ export function usePatientRecurrences() {
         error.value = '';
         rules.value = [];
         try {
-            const { data, error: err } = await supabase
-                .from('recurrence_rules')
-                .select('*')
-                .eq('patient_id', patientId)
-                .order('start_date', { ascending: false });
-            if (err) throw err;
-            rules.value = data || [];
+            rules.value = await listRecurrencesByPatient(patientId);
         } catch (e) {
-            error.value = e?.message || 'Falha ao carregar recorrencias.';
+            error.value = e?.message || 'Falha ao carregar recorrências.';
             rules.value = [];
         } finally {
             loading.value = false;
@@ -50,11 +47,7 @@ export function usePatientRecurrences() {
         if (!ruleId || busy.value) return { ok: false, error: 'busy' };
         busy.value = true;
         try {
-            const { error: err } = await supabase
-                .from('recurrence_rules')
-                .update({ status: 'cancelado', updated_at: new Date().toISOString() })
-                .eq('id', ruleId);
-            if (err) throw err;
+            await updateRecurrenceStatus(ruleId, 'cancelado');
             if (_lastPatientId) await load(_lastPatientId);
             return { ok: true };
         } catch (e) {
@@ -68,11 +61,7 @@ export function usePatientRecurrences() {
         if (!ruleId || busy.value) return { ok: false, error: 'busy' };
         busy.value = true;
         try {
-            const { error: err } = await supabase
-                .from('recurrence_rules')
-                .update({ status: 'ativo', updated_at: new Date().toISOString() })
-                .eq('id', ruleId);
-            if (err) throw err;
+            await updateRecurrenceStatus(ruleId, 'ativo');
             if (_lastPatientId) await load(_lastPatientId);
             return { ok: true };
         } catch (e) {
diff --git a/src/features/patients/composables/usePatientSessions.js b/src/features/patients/composables/usePatientSessions.js
index 19395cd..17e73d9 100644
--- a/src/features/patients/composables/usePatientSessions.js
+++ b/src/features/patients/composables/usePatientSessions.js
@@ -4,23 +4,32 @@
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatientSessions.js
 |
-| Carrega sessoes (agenda_eventos) do paciente. Limit 100 mais recentes
-| ordenadas desc por inicio_em. Compativel com a logica original do
-| PatientProntuario.vue.
+| Carrega sessões (agenda_eventos) do paciente. Limit 100 reais + expansão
+| de recorrências do owner dentro de uma janela de 18 meses. Merge desc por
+| inicio_em pra alimentar prontuário/timeline.
+|
+| I/O delegada ao patientsRepository. Expansão de recorrência continua via
+| useRecurrence (composable da agenda — não é supabase direto, é orquestração).
 |--------------------------------------------------------------------------
 */
 import { ref, computed } from 'vue';
 import { supabase } from '@/lib/supabase/client';
 import { useRecurrence } from '@/features/agenda/composables/useRecurrence';
+import {
+    listSessionsByPatient,
+    createPatientSession,
+    updatePatientSessionStatus,
+    findSessionByRecurrence
+} from '@/features/patients/services/patientsRepository';
 
 export function usePatientSessions() {
     const sessions = ref([]);
     const loading = ref(false);
     const error = ref('');
-    const busy = ref(false); // mutations em curso (updateStatus etc)
+    const busy = ref(false);
+    // State per-instância — não vaza
     let _lastPatientId = null;
 
-    // Instancia local — refs internos (rules/exceptions) ficam isolados deste consumidor.
     const { loadAndExpand } = useRecurrence();
 
     async function load(patientId) {
@@ -33,23 +42,14 @@ export function usePatientSessions() {
         error.value = '';
         sessions.value = [];
         try {
-            // 1. Linhas reais — `recurrence_id`/`recurrence_date` inclusos pra
-            //    mergeWithStoredSessions deduplicar virtuais de sessões já materializadas.
-            const { data, error: err } = await supabase
-                .from('agenda_eventos')
-                .select('id, inicio_em, fim_em, status, modalidade, tipo, titulo, titulo_custom, observacoes, patient_id, recurrence_id, recurrence_date')
-                .eq('patient_id', patientId)
-                .order('inicio_em', { ascending: false })
-                .limit(100);
-            if (err) throw err;
-            const realRows = data || [];
+            // 1. Linhas reais via repository
+            const realRows = await listSessionsByPatient(patientId);
 
-            // 2. Expande recorrências do owner + filtra só as deste paciente.
-            //    Range default: 6 meses atrás → 12 meses à frente (cobre histórico
-            //    recente + ~1 ano de séries semanais/quinzenais futuras). Sem expansão,
-            //    sessão 1 aparece (materializada) mas as N-1 virtuais ficam invisíveis.
+            // 2. Expande recorrências do owner + filtra pra este paciente.
+            //    Range: 6 meses atrás → 12 meses à frente (histórico + ~1 ano de séries futuras).
             let virtualOccs = [];
             try {
+                // auth.getUser é context, não data query — pode ficar inline.
                 const { data: userData } = await supabase.auth.getUser();
                 const ownerId = userData?.user?.id || null;
                 if (ownerId) {
@@ -57,7 +57,9 @@ export function usePatientSessions() {
                     try {
                         const { useTenantStore } = await import('@/stores/tenantStore');
                         tenantId = useTenantStore().activeTenantId || null;
-                    } catch { /* sem tenant store — segue */ }
+                    } catch {
+                        /* sem tenant store — segue */
+                    }
 
                     const now = new Date();
                     const rangeStart = new Date(now.getFullYear(), now.getMonth() - 6, 1);
@@ -67,12 +69,12 @@ export function usePatientSessions() {
                     virtualOccs = expanded.filter((r) => r.is_occurrence && r.patient_id === patientId);
                 }
             } catch (e) {
-                // Fallback silencioso — UI segue funcional só com sessões reais.
+                // Fallback silencioso — UI segue só com sessões reais.
                 // eslint-disable-next-line no-console
                 console.warn('[usePatientSessions] recurrence expand falhou:', e);
             }
 
-            // 3. Merge desc por inicio_em (mantém contrato do composable original).
+            // 3. Merge desc por inicio_em
             const merged = [...realRows, ...virtualOccs];
             merged.sort((a, b) => String(b.inicio_em).localeCompare(String(a.inicio_em)));
             sessions.value = merged;
@@ -84,122 +86,63 @@ export function usePatientSessions() {
         }
     }
 
-    // Helpers derivados — proxima sessao agendada e status corrente
+    // ─── Computeds derivados ────────────────────────────────
+
     const proximaSessao = computed(() => {
         const now = Date.now();
-        return [...sessions.value]
-            .filter((s) => s.inicio_em && new Date(s.inicio_em).getTime() >= now)
-            .sort((a, b) => new Date(a.inicio_em) - new Date(b.inicio_em))[0] || null;
+        return (
+            [...sessions.value]
+                .filter((s) => s.inicio_em && new Date(s.inicio_em).getTime() >= now)
+                .sort((a, b) => new Date(a.inicio_em) - new Date(b.inicio_em))[0] || null
+        );
     });
 
     const ultimaSessao = computed(() => {
         const now = Date.now();
-        return sessions.value
-            .filter((s) => s.inicio_em && new Date(s.inicio_em).getTime() < now)
-            .sort((a, b) => new Date(b.inicio_em) - new Date(a.inicio_em))[0] || null;
+        return (
+            sessions.value
+                .filter((s) => s.inicio_em && new Date(s.inicio_em).getTime() < now)
+                .sort((a, b) => new Date(b.inicio_em) - new Date(a.inicio_em))[0] || null
+        );
     });
 
     const totalSessoes = computed(() => sessions.value.length);
 
-    // Conta status com regex pra cobrir variantes pt-br
-    // (realizada/realizado/presente; falta/faltou; cancelada/cancelado/remarcada).
-    const totalRealizadas = computed(() =>
-        sessions.value.filter((s) => /realiz|present/i.test(String(s.status || ''))).length
-    );
-    const totalFaltas = computed(() =>
-        sessions.value.filter((s) => /falt/i.test(String(s.status || ''))).length
-    );
-    const totalCanceladas = computed(() =>
-        sessions.value.filter((s) => /cancel|remarca/i.test(String(s.status || ''))).length
-    );
+    const totalRealizadas = computed(() => sessions.value.filter((s) => /realiz|present/i.test(String(s.status || ''))).length);
+    const totalFaltas = computed(() => sessions.value.filter((s) => /falt/i.test(String(s.status || ''))).length);
+    const totalCanceladas = computed(() => sessions.value.filter((s) => /cancel|remarca/i.test(String(s.status || ''))).length);
 
-    /**
-     * Top 6 sessoes "atendidas" (qualquer status que indica encontro: realizado,
-     * faltou, cancelado, remarcado) — alimenta a Timeline da Visao Geral.
-     */
     const ultimasAtendidas = computed(() =>
-        sessions.value
-            .filter((s) => /realiz|present|falt|cancel|remarca/i.test(String(s.status || '')))
-            .slice(0, 6)
+        sessions.value.filter((s) => /realiz|present|falt|cancel|remarca/i.test(String(s.status || ''))).slice(0, 6)
     );
 
-    /**
-     * Cria uma nova sessao na agenda do paciente.
-     *
-     * payload: {
-     *   inicio_em: ISO timestamp,
-     *   fim_em: ISO timestamp,
-     *   tipo: 'sessao' | 'primeira' | 'retorno' | etc,
-     *   modalidade: 'presencial' | 'online',
-     *   titulo?: string,
-     *   titulo_custom?: string,
-     *   observacoes?: string
-     * }
-     * Retorna {ok, data?, error?}.
-     */
+    // ─── Mutations ─────────────────────────────────────────
+
     async function createSession(patientId, payload = {}) {
         if (!patientId || busy.value) return { ok: false, error: 'busy' };
         if (!payload?.inicio_em || !payload?.fim_em) {
-            return { ok: false, error: 'Inicio/fim obrigatorios' };
+            return { ok: false, error: 'Início/fim obrigatórios' };
         }
         busy.value = true;
         try {
-            const { data: userData } = await supabase.auth.getUser();
-            const ownerId = userData?.user?.id;
-            let tenantId = null;
-            try {
-                const { useTenantStore } = await import('@/stores/tenantStore');
-                tenantId = useTenantStore().activeTenantId || null;
-            } catch { /* sem tenant store — segue */ }
-
-            const row = {
-                patient_id: patientId,
-                owner_id: ownerId,
-                tenant_id: tenantId,
-                inicio_em: payload.inicio_em,
-                fim_em: payload.fim_em,
-                status: 'agendado',
-                modalidade: payload.modalidade || 'presencial',
-                tipo: payload.tipo || 'sessao',
-                titulo: String(payload.titulo || '').trim() || null,
-                titulo_custom: String(payload.titulo_custom || '').trim() || null,
-                observacoes: String(payload.observacoes || '').trim() || null
-            };
-
-            const { data, error: err } = await supabase
-                .from('agenda_eventos')
-                .insert([row])
-                .select()
-                .single();
-            if (err) throw err;
+            const data = await createPatientSession(patientId, payload);
             if (_lastPatientId) await load(_lastPatientId);
             return { ok: true, data };
         } catch (e) {
-            return { ok: false, error: e?.message || 'Erro ao agendar sessao' };
+            return { ok: false, error: e?.message || 'Erro ao agendar sessão' };
         } finally {
             busy.value = false;
         }
     }
 
     /**
-     * Atualiza o status de uma sessao (mutation). Recarrega a lista do paciente
-     * ao final pra refletir o novo estado nos computeds derivados.
-     *
-     * Aceita string (UUID legado) OU a row inteira da sessão. Quando vier a row
-     * e ela for ocorrência virtual (is_occurrence=true, id `rec::ruleId::date`),
-     * MATERIALIZA primeiro: cria/encontra a linha real em agenda_eventos com
-     * recurrence_id+recurrence_date apontando pra regra, depois aplica o status.
-     * Sem isso o UPDATE falha com "invalid input syntax for type uuid" porque
-     * o id virtual nunca existiu no banco. Espelha o pattern de
-     * useMelissaAgenda.onUpdateSeriesEvent (L808-850).
-     *
-     * Retorna {ok: true} ou {ok: false, error: msg}.
+     * Atualiza status — aceita UUID string OU row inteira. Se virtual
+     * (is_occurrence), materializa antes via createPatientSession.
      */
     async function updateStatus(sessionOrId, novoStatus) {
         if (!sessionOrId || busy.value) return { ok: false, error: 'busy' };
         busy.value = true;
         try {
-            // Caminho A — string UUID legado ou row real (id é UUID real).
             const isObject = typeof sessionOrId === 'object' && sessionOrId !== null;
             const isVirtual = isObject && !!sessionOrId.is_occurrence;
 
@@ -208,16 +151,12 @@ export function usePatientSessions() {
                 if (!realId || typeof realId !== 'string' || realId.startsWith('rec::')) {
                     return { ok: false, error: 'ID inválido pra atualizar status (virtual sem row).' };
                 }
-                const { error: err } = await supabase
-                    .from('agenda_eventos')
-                    .update({ status: novoStatus })
-                    .eq('id', realId);
-                if (err) throw err;
+                await updatePatientSessionStatus(realId, novoStatus);
                 if (_lastPatientId) await load(_lastPatientId);
                 return { ok: true };
             }
 
-            // Caminho B — ocorrência virtual: materializar antes de atualizar.
+            // Virtual: materializar antes
             const row = sessionOrId;
             const rid = row.recurrence_id;
             const rDate = row.recurrence_date || row.original_date || String(row.inicio_em || '').slice(0, 10);
@@ -226,52 +165,25 @@ export function usePatientSessions() {
                 return { ok: false, error: 'Ocorrência sem recurrence_id/date — não dá pra materializar.' };
             }
 
-            // Já existe row materializada (mesmo recurrence_id+date)? Usa ela.
-            const { data: existing, error: exErr } = await supabase
-                .from('agenda_eventos')
-                .select('id')
-                .eq('recurrence_id', rid)
-                .eq('recurrence_date', rDate)
-                .maybeSingle();
-            if (exErr) throw exErr;
-
+            const existing = await findSessionByRecurrence(rid, rDate);
             if (existing?.id) {
-                const { error: upErr } = await supabase
-                    .from('agenda_eventos')
-                    .update({ status: novoStatus })
-                    .eq('id', existing.id);
-                if (upErr) throw upErr;
+                await updatePatientSessionStatus(existing.id, novoStatus);
             } else {
-                // Materializa NOVA row a partir da virtual. Owner/tenant via auth+store.
-                const { data: userData } = await supabase.auth.getUser();
-                const ownerId = userData?.user?.id || null;
-                let tenantId = null;
-                try {
-                    const { useTenantStore } = await import('@/stores/tenantStore');
-                    tenantId = useTenantStore().activeTenantId || null;
-                } catch { /* sem store — segue */ }
-
-                const newRow = {
-                    owner_id: ownerId,
-                    tenant_id: tenantId,
-                    recurrence_id: rid,
-                    recurrence_date: rDate,
-                    patient_id: row.patient_id || row.paciente_id || _lastPatientId,
-                    tipo: row.tipo || 'sessao',
-                    status: novoStatus,
+                // Cria row real materializada (createPatientSession suporta recurrence_id/date)
+                await createPatientSession(row.patient_id || row.paciente_id || _lastPatientId, {
                     inicio_em: row.inicio_em,
                     fim_em: row.fim_em,
+                    status: novoStatus,
                     modalidade: row.modalidade || 'presencial',
-                    titulo: row.titulo || null,
-                    titulo_custom: row.titulo_custom || null,
-                    observacoes: row.observacoes || null,
-                    determined_commitment_id: row.determined_commitment_id || null,
-                    price: row.price ?? null
-                };
-                const { error: insErr } = await supabase
-                    .from('agenda_eventos')
-                    .insert([newRow]);
-                if (insErr) throw insErr;
+                    tipo: row.tipo || 'sessao',
+                    titulo: row.titulo,
+                    titulo_custom: row.titulo_custom,
+                    observacoes: row.observacoes,
+                    recurrence_id: rid,
+                    recurrence_date: rDate,
+                    determined_commitment_id: row.determined_commitment_id,
+                    price: row.price
+                });
             }
 
             if (_lastPatientId) await load(_lastPatientId);
diff --git a/src/features/patients/composables/usePatientSupportContacts.js b/src/features/patients/composables/usePatientSupportContacts.js
index f23eb04..099b8a4 100644
--- a/src/features/patients/composables/usePatientSupportContacts.js
+++ b/src/features/patients/composables/usePatientSupportContacts.js
@@ -3,13 +3,16 @@
 | Agência PSI
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatientSupportContacts.js
-| V#9 — composable de contatos de suporte do paciente (responsável, parente,
-| amigo). Encapsula CRUD + estado reativo.
+| V#9 — contatos de suporte do paciente (responsável, parente, amigo).
+| Encapsula CRUD + estado reativo. I/O delegada ao patientsRepository.
 |--------------------------------------------------------------------------
 */
 import { ref } from 'vue';
-import { supabase } from '@/lib/supabase/client';
 import { digitsOnly, fmtPhone } from '@/utils/validators';
+import {
+    listSupportContactsByPatient,
+    replacePatientSupportContacts
+} from '@/features/patients/services/patientsRepository';
 
 function novoContato() {
     return {
@@ -55,12 +58,7 @@ export function usePatientSupportContacts() {
         }
         loading.value = true;
         try {
-            const { data, error } = await supabase
-                .from('patient_support_contacts')
-                .select('*')
-                .eq('patient_id', patientId)
-                .order('is_primario', { ascending: false });
-            if (error) throw error;
+            const data = await listSupportContactsByPatient(patientId);
             contatos.value = (data || []).map((c) => ({
                 _k: c.id,
                 nome: c.nome || '',
@@ -71,6 +69,7 @@ export function usePatientSupportContacts() {
                 is_primario: !!c.is_primario
             }));
         } catch {
+            // Fallback silencioso pra não quebrar prontuário se tabela estiver vazia/RLS
             contatos.value = [];
         } finally {
             loading.value = false;
@@ -79,26 +78,13 @@ export function usePatientSupportContacts() {
 
     /**
      * Substitui contatos do paciente: deleta tudo do owner + reinserta os com nome.
-     * @param {string} patientId
-     * @param {string} tenantId
-     * @param {string} ownerId
      */
     async function save(patientId, tenantId, ownerId) {
         if (!patientId) throw new Error('patientId obrigatório');
 
-        const { error: del } = await supabase
-            .from('patient_support_contacts')
-            .delete()
-            .eq('patient_id', patientId)
-            .eq('owner_id', ownerId);
-        if (del) throw del;
-
         const rows = contatos.value
             .filter((c) => c.nome.trim())
             .map((c) => ({
-                patient_id: patientId,
-                owner_id: ownerId,
-                tenant_id: tenantId,
                 nome: c.nome.trim() || null,
                 relacao: c.relacao || null,
                 tipo: c.tipo || null,
@@ -107,9 +93,8 @@ export function usePatientSupportContacts() {
                 is_primario: !!c.is_primario
             }));
 
-        if (!rows.length) return;
-        const { error: ins } = await supabase.from('patient_support_contacts').insert(rows);
-        if (ins) throw ins;
+        // Repository injeta patient_id, owner_id, tenant_id em cada row
+        await replacePatientSupportContacts(patientId, rows, { tenantId, ownerId });
     }
 
     return { contatos, loading, add, remove, reset, iniciaisFor, load, save };
diff --git a/src/features/patients/composables/usePatients.js b/src/features/patients/composables/usePatients.js
index ca71d24..1e1e53e 100644
--- a/src/features/patients/composables/usePatients.js
+++ b/src/features/patients/composables/usePatients.js
@@ -3,8 +3,10 @@
 | Agência PSI
 |--------------------------------------------------------------------------
 | Arquivo: src/features/patients/composables/usePatients.js
-| V#3 — composable que agrega estado reativo (rows/loading/error) e delega
-| toda I/O ao patientsRepository. Mesmo padrão de useAgendaEvents.
+|
+| Thin wrapper sobre patientsRepository (composable-blueprint Tipo A).
+| Toda I/O delegada ao repository. State reativo: rows, loading, error.
+| Mutations re-throw após registrar error.value pra caller decidir UX.
 |--------------------------------------------------------------------------
 */
 import { ref } from 'vue';
@@ -19,11 +21,11 @@ import {
 export function usePatients() {
     const rows = ref([]);
     const loading = ref(false);
-    const error = ref(null);
+    const error = ref('');
 
     async function load(opts) {
         loading.value = true;
-        error.value = null;
+        error.value = '';
         try {
             rows.value = await listPatients(opts);
         } catch (e) {
@@ -35,19 +37,55 @@ export function usePatients() {
     }
 
     async function getById(id, opts) {
-        return getPatientById(id, opts);
+        loading.value = true;
+        error.value = '';
+        try {
+            return await getPatientById(id, opts);
+        } catch (e) {
+            error.value = e?.message || 'Erro ao carregar paciente';
+            return null;
+        } finally {
+            loading.value = false;
+        }
     }
 
     async function create(payload) {
-        return createPatient(payload);
+        loading.value = true;
+        error.value = '';
+        try {
+            return await createPatient(payload);
+        } catch (e) {
+            error.value = e?.message || 'Erro ao criar paciente';
+            throw e;
+        } finally {
+            loading.value = false;
+        }
     }
 
     async function update(id, patch, opts) {
-        return updatePatient(id, patch, opts);
+        loading.value = true;
+        error.value = '';
+        try {
+            return await updatePatient(id, patch, opts);
+        } catch (e) {
+            error.value = e?.message || 'Erro ao atualizar paciente';
+            throw e;
+        } finally {
+            loading.value = false;
+        }
     }
 
     async function remove(id, opts) {
-        await softDeletePatient(id, opts);
+        loading.value = true;
+        error.value = '';
+        try {
+            await softDeletePatient(id, opts);
+        } catch (e) {
+            error.value = e?.message || 'Erro ao remover paciente';
+            throw e;
+        } finally {
+            loading.value = false;
+        }
     }
 
     return { rows, loading, error, load, getById, create, update, remove };
diff --git a/src/features/patients/services/patientsRepository.js b/src/features/patients/services/patientsRepository.js
index 62f73e8..cdc9fea 100644
--- a/src/features/patients/services/patientsRepository.js
+++ b/src/features/patients/services/patientsRepository.js
@@ -5,25 +5,41 @@
 | Arquivo: src/features/patients/services/patientsRepository.js
 | V#3 — fundação: queries de patients centralizadas.
 |
-| Mesmo padrão de feature/agenda/services/agendaRepository.js. Pages devem
-| chamar este repo em vez de fazer supabase.from('patients') direto.
+| Pages e composables devem chamar este repo em vez de fazer
+| supabase.from('patients') direto.
+|
+| Inclui também reads cross-feature em escopo de paciente (agenda_eventos,
+| financial_records, documents, recurrence_rules, conversation_messages,
+| patient_support_contacts) — usados pelos sub-composables do prontuário.
+| Quando M4 (Financeiro) / M6 (Notificações/Conversations) padronizarem
+| esses domínios, as funções respectivas migram pra repositories nativos.
 |--------------------------------------------------------------------------
 */
 import { supabase } from '@/lib/supabase/client';
+import { useTenantStore } from '@/stores/tenantStore';
 import { assertTenantId, getUid } from '@/features/agenda/services/_tenantGuards';
+import {
+    PATIENTS_SELECT_BASE,
+    PATIENT_SESSIONS_SELECT,
+    PATIENT_FINANCIAL_RECORDS_SELECT,
+    PATIENT_DOCUMENTS_SELECT,
+    PATIENT_MESSAGES_SELECT,
+    PATIENT_RECURRENCE_RULES_SELECT,
+    PATIENT_SUPPORT_CONTACTS_SELECT,
+    PATIENT_GROUPS_SELECT,
+    PATIENT_GROUPS_SELECT_BRIEF,
+    PATIENT_TAGS_SELECT,
+    PATIENT_TAGS_SELECT_BRIEF
+} from './patientsSelects';
 
-const PATIENTS_SELECT_BASE = `
-    id, tenant_id, owner_id, user_id, responsible_member_id, therapist_member_id,
-    nome_completo, email_principal, email_alternativo, telefone, telefone_alternativo,
-    cpf, rg, data_nascimento, naturalidade, genero, estado_civil,
-    profissao, escolaridade, status,
-    cep, endereco, numero, bairro, complemento, cidade, estado, pais,
-    nome_responsavel, telefone_responsavel, cpf_responsavel, observacao_responsavel,
-    cobranca_no_responsavel,
-    onde_nos_conheceu, encaminhado_por, observacoes,
-    last_attended_at, created_at, updated_at,
-    risco_sinalizado_por, convenio_id, patient_scope
-`;
+// ─── Helpers internos ────────────────────────────────────────────────────────
+
+function resolveTenantId(tenantIdArg) {
+    const tenantStore = useTenantStore();
+    const tenantId = tenantIdArg || tenantStore.activeTenantId || tenantStore.tenantId;
+    assertTenantId(tenantId);
+    return tenantId;
+}
 
 // ─────────────────────────────────────────────────────────────────────────
 // Patients core
@@ -31,12 +47,11 @@ const PATIENTS_SELECT_BASE = `
 
 /**
  * Lista pacientes do tenant ativo. Aceita filtros opcionais.
- * @param {object} opts - { tenantId, ownerId?, includeInactive?, limit? }
  */
 export async function listPatients({ tenantId, ownerId = null, includeInactive = true, limit = null } = {}) {
-    assertTenantId(tenantId);
+    const tid = resolveTenantId(tenantId);
 
-    let q = supabase.from('patients').select(PATIENTS_SELECT_BASE).eq('tenant_id', tenantId);
+    let q = supabase.from('patients').select(PATIENTS_SELECT_BASE).eq('tenant_id', tid);
     if (ownerId) q = q.eq('owner_id', ownerId);
     if (!includeInactive) q = q.neq('status', 'Inativo');
     if (limit) q = q.limit(limit);
@@ -49,22 +64,21 @@ export async function listPatients({ tenantId, ownerId = null, includeInactive =
 
 export async function getPatientById(id, { tenantId } = {}) {
     if (!id) throw new Error('id obrigatório');
-    assertTenantId(tenantId);
-    const { data, error } = await supabase
-        .from('patients')
-        .select(PATIENTS_SELECT_BASE)
-        .eq('id', id)
-        .eq('tenant_id', tenantId)
-        .maybeSingle();
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase.from('patients').select(PATIENTS_SELECT_BASE).eq('id', id).eq('tenant_id', tid).maybeSingle();
     if (error) throw error;
     return data;
 }
 
 export async function createPatient(payload) {
-    const tenantId = payload?.tenant_id;
-    assertTenantId(tenantId);
-    const ownerId = payload?.owner_id || (await getUid());
-    const row = { ...payload, tenant_id: tenantId, owner_id: ownerId };
+    const tid = resolveTenantId(payload?.tenant_id);
+    // owner_id SEMPRE injetado do uid logado (não aceita do payload).
+    // Audit baseline alta (2026-05-20): aceitar do payload permitiria
+    // criar pacientes "de outro terapeuta". Repository é defesa em profundidade.
+    const ownerId = await getUid();
+    // eslint-disable-next-line no-unused-vars
+    const { owner_id: _dropped, ...rest } = payload || {};
+    const row = { ...rest, tenant_id: tid, owner_id: ownerId };
     const { data, error } = await supabase.from('patients').insert(row).select(PATIENTS_SELECT_BASE).single();
     if (error) throw error;
     return data;
@@ -72,84 +86,27 @@ export async function createPatient(payload) {
 
 export async function updatePatient(id, patch, { tenantId } = {}) {
     if (!id) throw new Error('id obrigatório');
-    assertTenantId(tenantId);
-    const { data, error } = await supabase
-        .from('patients')
-        .update(patch)
-        .eq('id', id)
-        .eq('tenant_id', tenantId)
-        .select(PATIENTS_SELECT_BASE)
-        .single();
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase.from('patients').update(patch).eq('id', id).eq('tenant_id', tid).select(PATIENTS_SELECT_BASE).single();
     if (error) throw error;
     return data;
 }
 
 export async function softDeletePatient(id, { tenantId } = {}) {
     if (!id) throw new Error('id obrigatório');
-    assertTenantId(tenantId);
-    const { error } = await supabase
-        .from('patients')
-        .update({ status: 'Arquivado' })
-        .eq('id', id)
-        .eq('tenant_id', tenantId);
+    const tid = resolveTenantId(tenantId);
+    const { error } = await supabase.from('patients').update({ status: 'Arquivado' }).eq('id', id).eq('tenant_id', tid);
     if (error) throw error;
 }
 
-// Pra restaurar um paciente arquivado, use `reactivatePatient` do
-// composable `usePatientLifecycle` — fonte única de verdade pra toda
-// transição de status (Inativo/Arquivado/Alta/Encaminhado → Ativo).
+// Pra restaurar paciente arquivado, use `reactivatePatient` do `usePatientLifecycle`.
 
 // ─────────────────────────────────────────────────────────────────────────
-// Groups
+// Patient Relations (groups + tags)
 // -----------------------------------------------------------------------------
-export async function listGroups({ tenantId, ownerId = null } = {}) {
-    assertTenantId(tenantId);
-    let q = supabase.from('patient_groups').select('id, nome, cor, is_system, owner_id, is_active').eq('tenant_id', tenantId).eq('is_active', true);
-    if (ownerId) q = q.or(`is_system.eq.true,owner_id.eq.${ownerId}`);
-    q = q.order('nome', { ascending: true });
-    const { data, error } = await q;
-    if (error) throw error;
-    return (data || []).map((g) => ({ id: g.id, name: g.nome, color: g.cor, isSystem: g.is_system }));
-}
-
-export async function listGroupsByPatient(patientIds, { tenantId } = {}) {
-    if (!patientIds?.length) return [];
-    assertTenantId(tenantId);
-    const { data, error } = await supabase
-        .from('patient_group_patient')
-        .select('patient_id, patient_group_id')
-        .eq('tenant_id', tenantId)
-        .in('patient_id', patientIds);
-    if (error) throw error;
-    return data || [];
-}
-
-// ─────────────────────────────────────────────────────────────────────────
-// Tags
-// -----------------------------------------------------------------------------
-export async function listTags({ tenantId, ownerId = null } = {}) {
-    assertTenantId(tenantId);
-    let q = supabase.from('patient_tags').select('id, nome, cor, owner_id').eq('tenant_id', tenantId);
-    if (ownerId) q = q.eq('owner_id', ownerId);
-    const { data, error } = await q;
-    if (error) throw error;
-    return (data || []).map((t) => ({ id: t.id, name: t.nome, color: t.cor }));
-}
-
-export async function listTagsByPatient(patientIds, { tenantId } = {}) {
-    if (!patientIds?.length) return [];
-    assertTenantId(tenantId);
-    const { data, error } = await supabase
-        .from('patient_patient_tag')
-        .select('patient_id, tag_id')
-        .eq('tenant_id', tenantId)
-        .in('patient_id', patientIds);
-    if (error) throw error;
-    return data || [];
-}
 
 /**
- * Retorna {groupIds, tagIds} de um paciente.
+ * Retorna {groupIds, tagIds} de um paciente (joins junior tables).
  */
 export async function getPatientRelations(patientId) {
     if (!patientId) return { groupIds: [], tagIds: [] };
@@ -165,48 +122,398 @@ export async function getPatientRelations(patientId) {
     };
 }
 
+// ─── Groups ────────────────────────────────────────────────────────────────
+
+export async function listGroups({ tenantId, ownerId = null } = {}) {
+    const tid = resolveTenantId(tenantId);
+    let q = supabase.from('patient_groups').select(PATIENT_GROUPS_SELECT).eq('tenant_id', tid).eq('is_active', true);
+    if (ownerId) q = q.or(`is_system.eq.true,owner_id.eq.${ownerId}`);
+    q = q.order('nome', { ascending: true });
+    const { data, error } = await q;
+    if (error) throw error;
+    return (data || []).map((g) => ({ id: g.id, name: g.nome, color: g.cor, isSystem: g.is_system }));
+}
+
+export async function listGroupsByPatient(patientIds, { tenantId } = {}) {
+    if (!patientIds?.length) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase.from('patient_group_patient').select('patient_id, patient_group_id').eq('tenant_id', tid).in('patient_id', patientIds);
+    if (error) throw error;
+    return data || [];
+}
+
+/**
+ * Lê grupos por ids (brief — id+name). Usado em prontuário pra mostrar pílulas.
+ */
+export async function getGroupsByIds(ids) {
+    if (!ids?.length) return [];
+    const { data, error } = await supabase.from('patient_groups').select(PATIENT_GROUPS_SELECT_BRIEF).in('id', ids).order('nome', { ascending: true });
+    if (error) throw error;
+    return (data || []).map((g) => ({ id: g.id, name: g.nome }));
+}
+
 /**
  * Substitui o grupo do paciente (1:1 — sistema atual).
  */
 export async function replacePatientGroup(patientId, groupId, { tenantId } = {}) {
     if (!patientId) throw new Error('patientId obrigatório');
-    const { error: del } = await supabase.from('patient_group_patient').delete().eq('patient_id', patientId);
+    const tid = resolveTenantId(tenantId);
+    const { error: del } = await supabase.from('patient_group_patient').delete().eq('patient_id', patientId).eq('tenant_id', tid);
     if (del) throw del;
     if (!groupId) return;
-    const { error: ins } = await supabase
-        .from('patient_group_patient')
-        .insert({ patient_id: patientId, patient_group_id: groupId, tenant_id: tenantId });
+    const { error: ins } = await supabase.from('patient_group_patient').insert({ patient_id: patientId, patient_group_id: groupId, tenant_id: tid });
     if (ins) throw ins;
 }
 
+// ─── Tags ──────────────────────────────────────────────────────────────────
+
+export async function listTags({ tenantId, ownerId = null } = {}) {
+    const tid = resolveTenantId(tenantId);
+    let q = supabase.from('patient_tags').select(PATIENT_TAGS_SELECT).eq('tenant_id', tid);
+    if (ownerId) q = q.eq('owner_id', ownerId);
+    const { data, error } = await q;
+    if (error) throw error;
+    return (data || []).map((t) => ({ id: t.id, name: t.nome, color: t.cor }));
+}
+
+export async function listTagsByPatient(patientIds, { tenantId } = {}) {
+    if (!patientIds?.length) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase.from('patient_patient_tag').select('patient_id, tag_id').eq('tenant_id', tid).in('patient_id', patientIds);
+    if (error) throw error;
+    return data || [];
+}
+
 /**
- * Substitui as tags do paciente (lista). Limpa antigas do owner + inserta as novas.
+ * Lê tags por ids (brief — id+name+color). Usado em prontuário.
+ */
+export async function getTagsByIds(ids) {
+    if (!ids?.length) return [];
+    const { data, error } = await supabase.from('patient_tags').select(PATIENT_TAGS_SELECT_BRIEF).in('id', ids).order('nome', { ascending: true });
+    if (error) throw error;
+    return (data || []).map((t) => ({ id: t.id, name: t.nome, color: t.cor }));
+}
+
+/**
+ * Substitui as tags do paciente.
  */
 export async function replacePatientTags(patientId, tagIds, { tenantId, ownerId } = {}) {
     if (!patientId) throw new Error('patientId obrigatório');
     if (!ownerId) throw new Error('ownerId obrigatório');
-    const { error: del } = await supabase
-        .from('patient_patient_tag')
-        .delete()
-        .eq('patient_id', patientId)
-        .eq('owner_id', ownerId);
+    const tid = resolveTenantId(tenantId);
+
+    const { error: del } = await supabase.from('patient_patient_tag').delete().eq('patient_id', patientId).eq('owner_id', ownerId).eq('tenant_id', tid);
     if (del) throw del;
 
     const clean = Array.from(new Set((tagIds || []).filter(Boolean)));
     if (!clean.length) return;
-    const { error: ins } = await supabase
-        .from('patient_patient_tag')
-        .insert(clean.map((tag_id) => ({ owner_id: ownerId, patient_id: patientId, tag_id, tenant_id: tenantId })));
+    const { error: ins } = await supabase.from('patient_patient_tag').insert(clean.map((tag_id) => ({ owner_id: ownerId, patient_id: patientId, tag_id, tenant_id: tid })));
     if (ins) throw ins;
 }
 
 // ─────────────────────────────────────────────────────────────────────────
-// Sessões agregadas (V#8 — get_patient_session_counts RPC)
+// Sessions (agenda_eventos) em escopo de paciente
 // -----------------------------------------------------------------------------
+// Cross-feature: chamadas pelo usePatientSessions. Migração futura: quando
+// agendaRepository for ampliado pra exportar listByPatient, este módulo deixa
+// de duplicar.
+
+/**
+ * Lista sessões reais (agenda_eventos) do paciente, 100 mais recentes desc.
+ */
+export async function listSessionsByPatient(patientId, { tenantId } = {}) {
+    if (!patientId) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase
+        .from('agenda_eventos')
+        .select(PATIENT_SESSIONS_SELECT)
+        .eq('tenant_id', tid)
+        .eq('patient_id', patientId)
+        .order('inicio_em', { ascending: false })
+        .limit(100);
+    if (error) throw error;
+    return data || [];
+}
+
+/**
+ * Cria sessão pro paciente. owner_id + tenant_id injetados pelo repository.
+ *
+ * payload aceita: inicio_em, fim_em, status?, modalidade?, tipo?, titulo?,
+ *   titulo_custom?, observacoes?, recurrence_id?, recurrence_date?,
+ *   determined_commitment_id?, price?
+ */
+export async function createPatientSession(patientId, payload) {
+    if (!patientId) throw new Error('patientId obrigatório');
+    if (!payload?.inicio_em || !payload?.fim_em) throw new Error('Início/fim obrigatórios');
+    const uid = await getUid();
+    const tid = resolveTenantId();
+
+    const row = {
+        patient_id: patientId,
+        owner_id: uid,
+        tenant_id: tid,
+        inicio_em: payload.inicio_em,
+        fim_em: payload.fim_em,
+        status: payload.status || 'agendado',
+        modalidade: payload.modalidade || 'presencial',
+        tipo: payload.tipo || 'sessao',
+        titulo: payload.titulo ? String(payload.titulo).trim() || null : null,
+        titulo_custom: payload.titulo_custom ? String(payload.titulo_custom).trim() || null : null,
+        observacoes: payload.observacoes ? String(payload.observacoes).trim() || null : null,
+        recurrence_id: payload.recurrence_id || null,
+        recurrence_date: payload.recurrence_date || null,
+        determined_commitment_id: payload.determined_commitment_id || null,
+        price: payload.price ?? null
+    };
+
+    const { data, error } = await supabase.from('agenda_eventos').insert([row]).select().single();
+    if (error) throw error;
+    return data;
+}
+
+/**
+ * Atualiza só o status de uma sessão (mutation comum em prontuário).
+ */
+export async function updatePatientSessionStatus(sessionId, status, { tenantId } = {}) {
+    if (!sessionId) throw new Error('sessionId obrigatório');
+    const tid = resolveTenantId(tenantId);
+    const { error } = await supabase.from('agenda_eventos').update({ status }).eq('id', sessionId).eq('tenant_id', tid);
+    if (error) throw error;
+}
+
+/**
+ * Procura sessão materializada por (recurrence_id, recurrence_date).
+ * Usado pra decidir entre UPDATE (já existe) e INSERT (materializar virtual).
+ */
+export async function findSessionByRecurrence(recurrenceId, recurrenceDate) {
+    if (!recurrenceId || !recurrenceDate) return null;
+    const { data, error } = await supabase.from('agenda_eventos').select('id').eq('recurrence_id', recurrenceId).eq('recurrence_date', recurrenceDate).maybeSingle();
+    if (error) throw error;
+    return data || null;
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Financial Records em escopo de paciente
+// -----------------------------------------------------------------------------
+// Cross-feature: migra pra features/financeiro/services no Módulo 4.
+
+/**
+ * Lista lançamentos do paciente (type=receita, 100 mais recentes).
+ */
+export async function listFinancialRecordsByPatient(patientId, { tenantId } = {}) {
+    if (!patientId) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase
+        .from('financial_records')
+        .select(PATIENT_FINANCIAL_RECORDS_SELECT)
+        .eq('tenant_id', tid)
+        .eq('patient_id', patientId)
+        .eq('type', 'receita')
+        .order('created_at', { ascending: false })
+        .limit(100);
+    if (error) throw error;
+    return data || [];
+}
+
+/**
+ * Cria lançamento manual pro paciente (type=receita).
+ */
+export async function createFinancialRecord(patientId, payload) {
+    if (!patientId) throw new Error('patientId obrigatório');
+    if (!payload?.amount || Number.isNaN(Number(payload.amount))) {
+        throw new Error('Valor inválido');
+    }
+    const uid = await getUid();
+    const tid = resolveTenantId();
+
+    const row = {
+        patient_id: patientId,
+        owner_id: uid,
+        tenant_id: tid,
+        type: 'receita',
+        amount: Number(payload.amount),
+        due_date: payload.due_date || null,
+        description: payload.description ? String(payload.description).trim() || null : null,
+        payment_method: payload.payment_method || null,
+        paid_at: null
+    };
+
+    const { data, error } = await supabase.from('financial_records').insert([row]).select().single();
+    if (error) throw error;
+    return data;
+}
+
+/**
+ * Marca lançamento como pago (paid_at = now).
+ */
+export async function markFinancialRecordPaid(recordId, { tenantId } = {}) {
+    if (!recordId) throw new Error('recordId obrigatório');
+    const tid = resolveTenantId(tenantId);
+    const { error } = await supabase.from('financial_records').update({ paid_at: new Date().toISOString() }).eq('id', recordId).eq('tenant_id', tid);
+    if (error) throw error;
+}
+
+/**
+ * Reverte: remove paid_at (volta pra pendente).
+ */
+export async function markFinancialRecordUnpaid(recordId, { tenantId } = {}) {
+    if (!recordId) throw new Error('recordId obrigatório');
+    const tid = resolveTenantId(tenantId);
+    const { error } = await supabase.from('financial_records').update({ paid_at: null }).eq('id', recordId).eq('tenant_id', tid);
+    if (error) throw error;
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Documents em escopo de paciente (deleted_at IS NULL)
+// -----------------------------------------------------------------------------
+
+export async function listDocumentsByPatient(patientId, { tenantId } = {}) {
+    if (!patientId) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase
+        .from('documents')
+        .select(PATIENT_DOCUMENTS_SELECT)
+        .eq('tenant_id', tid)
+        .eq('patient_id', patientId)
+        .is('deleted_at', null)
+        .order('created_at', { ascending: false })
+        .limit(200);
+    if (error) throw error;
+    return data || [];
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Messages (conversation_messages) em escopo de paciente
+// -----------------------------------------------------------------------------
+// Cross-feature: migra pra features/conversations no Módulo 6.
+
+export async function listMessagesByPatient(patientId, { tenantId } = {}) {
+    if (!patientId) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase
+        .from('conversation_messages')
+        .select(PATIENT_MESSAGES_SELECT)
+        .eq('tenant_id', tid)
+        .eq('patient_id', patientId)
+        .order('created_at', { ascending: false })
+        .limit(200);
+    if (error) throw error;
+    return data || [];
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Recurrence Rules em escopo de paciente
+// -----------------------------------------------------------------------------
+// Cross-feature: migra pra agendaRepository quando padronizado.
+
+export async function listRecurrencesByPatient(patientId, { tenantId } = {}) {
+    if (!patientId) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase
+        .from('recurrence_rules')
+        .select(PATIENT_RECURRENCE_RULES_SELECT)
+        .eq('tenant_id', tid)
+        .eq('patient_id', patientId)
+        .order('start_date', { ascending: false });
+    if (error) throw error;
+    return data || [];
+}
+
+/**
+ * Atualiza status da regra de recorrência (cancelado/ativo).
+ */
+export async function updateRecurrenceStatus(ruleId, status, { tenantId } = {}) {
+    if (!ruleId) throw new Error('ruleId obrigatório');
+    const tid = resolveTenantId(tenantId);
+    const { error } = await supabase.from('recurrence_rules').update({ status, updated_at: new Date().toISOString() }).eq('id', ruleId).eq('tenant_id', tid);
+    if (error) throw error;
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Support Contacts (patient_support_contacts)
+// -----------------------------------------------------------------------------
+
+export async function listSupportContactsByPatient(patientId, { tenantId } = {}) {
+    if (!patientId) return [];
+    const tid = resolveTenantId(tenantId);
+    const { data, error } = await supabase.from('patient_support_contacts').select(PATIENT_SUPPORT_CONTACTS_SELECT).eq('tenant_id', tid).eq('patient_id', patientId).order('is_primario', { ascending: false });
+    if (error) throw error;
+    return data || [];
+}
+
+/**
+ * Substitui todos os contatos do paciente (delete-then-insert).
+ * Pattern original do composable.
+ *
+ * @param {Array} contacts - rows já mapeadas (sem patient_id/tenant_id/owner_id — injetados aqui)
+ */
+export async function replacePatientSupportContacts(patientId, contacts, { tenantId, ownerId } = {}) {
+    if (!patientId) throw new Error('patientId obrigatório');
+    if (!ownerId) throw new Error('ownerId obrigatório');
+    const tid = resolveTenantId(tenantId);
+
+    const { error: del } = await supabase.from('patient_support_contacts').delete().eq('patient_id', patientId).eq('owner_id', ownerId).eq('tenant_id', tid);
+    if (del) throw del;
+
+    if (!contacts?.length) return;
+
+    const rows = contacts.map((c) => ({
+        ...c,
+        patient_id: patientId,
+        owner_id: ownerId,
+        tenant_id: tid
+    }));
+
+    const { error: ins } = await supabase.from('patient_support_contacts').insert(rows);
+    if (ins) throw ins;
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Patient Intake Requests (convert flow)
+// -----------------------------------------------------------------------------
+// Cross-feature: usado pelos 2 callers de "Cadastros recebidos"
+// (CadastrosRecebidosPage + MelissaCadastrosRecebidos). Centraliza a
+// transição intake → patient pra eliminar duplicação (Fase 2 — Graphify hotspot).
+
+/**
+ * Marca um patient_intake_request como convertido em paciente.
+ * Caller deve já ter criado o paciente via createPatient() antes.
+ *
+ * @param {string} intakeId
+ * @param {string} patientId  - id do paciente recém-criado
+ * @param {Object} [opts]
+ * @param {string} [opts.tenantId]
+ */
+export async function markIntakeConverted(intakeId, patientId, { tenantId } = {}) {
+    if (!intakeId) throw new Error('intakeId obrigatório.');
+    if (!patientId) throw new Error('patientId obrigatório.');
+
+    // tenant_id no patient_intake_requests pode ser nullable (intake público sem tenant)
+    // — só filtramos se passado explícito.
+    let q = supabase
+        .from('patient_intake_requests')
+        .update({
+            status: 'converted',
+            converted_patient_id: patientId,
+            updated_at: new Date().toISOString()
+        })
+        .eq('id', intakeId);
+
+    if (tenantId) {
+        const tid = resolveTenantId(tenantId);
+        q = q.eq('tenant_id', tid);
+    }
+
+    const { error } = await q;
+    if (error) throw error;
+}
+
+// ─────────────────────────────────────────────────────────────────────────
+// Sessions count aggregate (RPC já existente)
+// -----------------------------------------------------------------------------
+
 /**
  * Retorna contagem + última sessão por paciente. Usa RPC SECURITY DEFINER.
- * @param {string[]} patientIds
- * @returns {Array<{patient_id, session_count, last_session_at}>}
  */
 export async function getSessionCounts(patientIds) {
     if (!patientIds?.length) return [];
diff --git a/src/features/patients/services/patientsSelects.js b/src/features/patients/services/patientsSelects.js
new file mode 100644
index 0000000..d1151be
--- /dev/null
+++ b/src/features/patients/services/patientsSelects.js
@@ -0,0 +1,83 @@
+/*
+|--------------------------------------------------------------------------
+| Agência PSI
+|--------------------------------------------------------------------------
+| Arquivo: src/features/patients/services/patientsSelects.js
+|
+| Fonte única de SELECTs do feature patients. Inclui também SELECTs de
+| tabelas relacionadas (agenda_eventos, financial_records, etc) quando
+| usadas SOB ESCOPO de paciente — composables fazem listing por paciente
+| e precisam de SELECTs estáveis.
+|
+| Quando os módulos M4 (Financeiro) / M6 (Notificações/Conversations)
+| forem padronizados, os SELECTs cross-feature listados aqui podem migrar
+| pra repositories nativos. Por ora, centralizar no patients é pragmático.
+|--------------------------------------------------------------------------
+*/
+
+/** SELECT base de patients — usado em listPatients, getPatientById, etc. */
+export const PATIENTS_SELECT_BASE = `
+    id, tenant_id, owner_id, user_id, responsible_member_id, therapist_member_id,
+    nome_completo, email_principal, email_alternativo, telefone, telefone_alternativo,
+    cpf, rg, data_nascimento, naturalidade, genero, estado_civil,
+    profissao, escolaridade, status,
+    cep, endereco, numero, bairro, complemento, cidade, estado, pais,
+    nome_responsavel, telefone_responsavel, cpf_responsavel, observacao_responsavel,
+    cobranca_no_responsavel,
+    onde_nos_conheceu, encaminhado_por, observacoes,
+    last_attended_at, created_at, updated_at,
+    risco_sinalizado_por, convenio_id, patient_scope
+`
+    .replace(/\s+/g, ' ')
+    .trim();
+
+// ─── Cross-feature reads em escopo de paciente ──────────────────────────────
+
+/** Sessões (agenda_eventos) listadas por paciente. */
+export const PATIENT_SESSIONS_SELECT = `
+    id, inicio_em, fim_em, status, modalidade, tipo, titulo, titulo_custom,
+    observacoes, patient_id, recurrence_id, recurrence_date
+`
+    .replace(/\s+/g, ' ')
+    .trim();
+
+/** Lançamentos financeiros do paciente. */
+export const PATIENT_FINANCIAL_RECORDS_SELECT = `
+    id, type, amount, due_date, paid_at, description, payment_method, category, created_at
+`
+    .replace(/\s+/g, ' ')
+    .trim();
+
+/** Documentos do paciente — KPI/timeline (campos leves). */
+export const PATIENT_DOCUMENTS_SELECT = `
+    id, tipo_documento, created_at, status_revisao, tamanho_bytes
+`
+    .replace(/\s+/g, ' ')
+    .trim();
+
+/** Mensagens recentes do paciente. */
+export const PATIENT_MESSAGES_SELECT = `
+    id, body, direction, created_at, channel, kanban_status
+`
+    .replace(/\s+/g, ' ')
+    .trim();
+
+/** Regras de recorrência — composable usa todos os campos (UI rica). */
+export const PATIENT_RECURRENCE_RULES_SELECT = '*';
+
+/** Contatos de suporte (responsável, parente, etc) — formulário usa todos os campos. */
+export const PATIENT_SUPPORT_CONTACTS_SELECT = '*';
+
+// ─── Patient-native selects ─────────────────────────────────────────────────
+
+/** Grupos de pacientes (estrutura completa) — listGroups. */
+export const PATIENT_GROUPS_SELECT = 'id, nome, cor, is_system, owner_id, is_active';
+
+/** Grupos — versão brief (id+nome) usada em getGroupsByIds. */
+export const PATIENT_GROUPS_SELECT_BRIEF = 'id, nome';
+
+/** Tags do paciente — completa com owner. */
+export const PATIENT_TAGS_SELECT = 'id, nome, cor, owner_id';
+
+/** Tags — brief com cor (display em pílulas). */
+export const PATIENT_TAGS_SELECT_BRIEF = 'id, nome, cor';
diff --git a/src/layout/melissa/MelissaCadastrosRecebidos.vue b/src/layout/melissa/MelissaCadastrosRecebidos.vue
index 3bebf5f..c7751e5 100644
--- a/src/layout/melissa/MelissaCadastrosRecebidos.vue
+++ b/src/layout/melissa/MelissaCadastrosRecebidos.vue
@@ -17,6 +17,8 @@ import { useToast } from 'primevue/usetoast';
 import { useConfirm } from 'primevue/useconfirm';
 import { supabase } from '@/lib/supabase/client';
 import { useTenantStore } from '@/stores/tenantStore';
+// Fase 2 (Graphify hotspot): convertToPatient duplicado em 2 pages — extração pro repository.
+import { createPatient, markIntakeConverted } from '@/features/patients/services/patientsRepository';
 import { brToISO, isoToBR } from '@/utils/dateBR';
 // Dialog/Textarea/Button auto-imported via PrimeVueResolver
 
@@ -429,16 +431,12 @@ async function convertToPatient() {
             if (patientPayload[k] === undefined) delete patientPayload[k];
         });
 
-        const { data: created, error: insErr } = await supabase.from('patients')
-            .insert(patientPayload).select('id').single();
-        if (insErr) throw insErr;
+        // Repository chamadas (Fase 2 — convertToPatient de-dup).
+        const created = await createPatient(patientPayload);
         const patientId = created?.id;
         if (!patientId) throw new Error('Falha ao obter ID do paciente.');
 
-        const { error: upErr } = await supabase.from('patient_intake_requests')
-            .update({ status: 'converted', converted_patient_id: patientId, updated_at: new Date().toISOString() })
-            .eq('id', item.id);
-        if (upErr) throw upErr;
+        await markIntakeConverted(item.id, patientId);
 
         toast.add({ severity: 'success', summary: 'Convertido em paciente', life: 2500 });
         closeDlg();