@fayz-ai/db 0.14.0 → 0.16.0

package/migrations/075_o_apelido_da_referencia_nao_disputa_com_a_variavel.sql

@@ -0,0 +1,276 @@
+-- O apelido da referência não disputa com a variável.
+--
+-- A 071 filtra as referências opcionais com
+-- `jsonb_array_elements(v_unres) x` — e `x` já é uma variável declarada em
+-- `migration._upsert_row_impl` (ela guarda cada destino extra de uma Venda).
+-- O Postgres recusa a ambiguidade em vez de escolher:
+--
+--     column reference "x" is ambiguous
+--     DETAIL: It could refer to either a PL/pgSQL variable or a table column.
+--
+-- E recusa CERTO: adivinhar qual dos dois o autor queria seria pior que parar.
+--
+-- O efeito foi total, não parcial: a etapa `financial_movements` inteira
+-- abortou na primeira linha, e a rodada de quatro minutos que parecia ter
+-- passado não processou nada. Um erro de nome custou a passada toda.
+--
+-- Idempotente.
+
+CREATE OR REPLACE FUNCTION migration._upsert_row_impl(p_batch uuid, p_source_table text, p_source_numeric_id bigint, p_source_uuid uuid, p_cursor text, p_row jsonb)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO ''
+AS $function$
+DECLARE
+  b migration.batches%ROWTYPE;
+  a migration.allowlist%ROWTYPE;
+  l migration.ledger%ROWTYPE;
+  v_checksum text := md5(p_row::text);
+  v_target_table text;
+  v_target_id uuid;
+  v_mapped jsonb; v_row jsonb; v_meta jsonb; v_unres jsonb;
+  v_dest jsonb; v_fin jsonb;
+  v_res jsonb; v_status text; v_col text; v_excl text;
+  v_retry_split boolean := false;
+  -- O V1 manda: ver migration.is_mirroring() e o cabeçalho deste arquivo.
+  v_mirror boolean := false;
+  x jsonb; v_xid bigint;
+BEGIN
+  SELECT * INTO b FROM migration.batches WHERE id = p_batch;
+  IF NOT FOUND THEN RAISE EXCEPTION 'upsert_row: unknown batch %', p_batch USING ERRCODE = 'P0002'; END IF;
+  IF b.status <> 'running' THEN
+    RAISE EXCEPTION 'upsert_row: batch % is % (only a running batch accepts rows)', p_batch, b.status USING ERRCODE = '55000';
+  END IF;
+  PERFORM migration._assert_fence(b.tenant_id);
+
+  v_mirror := coalesce(migration.is_mirroring(b.tenant_id), false);
+
+  SELECT * INTO a FROM migration.allowlist WHERE source_table = p_source_table;
+  v_target_table := a.target_table;
+
+  SELECT * INTO l FROM migration.ledger
+   WHERE source_project = b.source_project AND source_table = p_source_table
+     AND ((p_source_numeric_id IS NOT NULL AND source_numeric_id = p_source_numeric_id)
+       OR (p_source_numeric_id IS NULL AND source_uuid = p_source_uuid))
+     AND coalesce(target_table, '') = coalesce(v_target_table, '')
+   FOR UPDATE;
+  IF NOT FOUND THEN
+    INSERT INTO migration.ledger (source_project, source_table, source_numeric_id, source_uuid, tenant_id, target_table, checksum, cursor, batch_id, status)
+    VALUES (b.source_project, p_source_table, p_source_numeric_id, p_source_uuid, b.tenant_id, v_target_table, v_checksum, p_cursor, p_batch, 'pending')
+    RETURNING * INTO l;
+  ELSIF l.tenant_id <> b.tenant_id THEN
+    RETURN migration._quarantine(l.id, p_batch, 'tenant',
+      format('source row already belongs to tenant %s; this batch migrates tenant %s', l.tenant_id, b.tenant_id), p_row);
+  END IF;
+
+  -- allowlist
+  IF p_source_table LIKE 'import\_ef\_%' OR EXISTS (SELECT 1 FROM migration.excluded_tables e WHERE e.source_table = p_source_table) THEN
+    SELECT reason INTO v_excl FROM migration.excluded_tables e WHERE e.source_table = CASE WHEN p_source_table LIKE 'import\_ef\_%' THEN 'import_ef_*' ELSE p_source_table END;
+    RETURN migration._quarantine(l.id, p_batch, 'allowlist', 'source table is explicitly excluded: ' || coalesce(v_excl, 'no reason recorded'), p_row,
+      NULL, 'recorded decision: the table is in migration.excluded_tables');
+  END IF;
+  IF a.source_table IS NULL THEN
+    RETURN migration._quarantine(l.id, p_batch, 'allowlist', format('source table %s is not in the core-A allowlist', p_source_table), p_row);
+  END IF;
+  -- tenant identity of the source row vs the batch
+  IF b.source_tenant_id IS NOT NULL AND (p_row ->> 'tenant_id') ~ '^\d+$' AND (p_row ->> 'tenant_id')::bigint <> b.source_tenant_id THEN
+    RETURN migration._quarantine(l.id, p_batch, 'tenant',
+      format('source row tenant_id %s differs from the batch source_tenant_id %s', p_row ->> 'tenant_id', b.source_tenant_id), p_row);
+  END IF;
+
+  -- idempotency + delta
+  IF EXISTS (SELECT 1 FROM migration.quarantine q WHERE q.ledger_id = l.id AND q.resolved_at IS NULL AND md5(q.payload::text) = v_checksum) THEN
+    PERFORM migration._count(p_batch, 'skipped');
+    RETURN jsonb_build_object('status', 'skipped', 'reason', 'quarantined and unresolved: ' || coalesce(l.reason, ''),
+                              'target_table', l.target_table, 'target_id', l.target_id, 'ledger_id', l.id);
+  END IF;
+  IF l.status = 'migrated' THEN
+    -- a split destination that did not exist on the first offer (invoice) and exists now: run the writer again
+    -- Duas formas da MESMA pergunta, e não uma com IS NOT DISTINCT FROM: esse
+    -- operador não vira condição de índice, então a sondagem virava varredura
+    -- da ledger inteira daquela tabela — 83 ms e 66 MB POR LINHA oferecida,
+    -- medido com 123.535 linhas de `clients`. Aqui cada ramo é um qual simples
+    -- sobre a chave que existe, e os dois têm índice:
+    --   numérica → ledger_source_numeric_key (source_project, source_table, source_numeric_id, …)
+    --   uuid     → ledger_source_uuid_idx    (source_project, source_table, source_uuid)
+    -- O ramo numérico não repete o casamento de uuid porque não precisa: dentro
+    -- de (projeto, tabela) o id numérico JÁ identifica a linha da origem, e as
+    -- irmãs no ledger são a mesma linha com outro destino.
+    IF l.source_numeric_id IS NOT NULL THEN
+      SELECT EXISTS (SELECT 1 FROM migration.ledger s
+                      WHERE s.source_project = l.source_project AND s.source_table = l.source_table
+                        AND s.source_numeric_id = l.source_numeric_id
+                        AND s.id <> l.id AND s.status IN ('pending', 'skipped') AND to_regclass(s.target_table) IS NOT NULL) INTO v_retry_split;
+    ELSE
+      SELECT EXISTS (SELECT 1 FROM migration.ledger s
+                      WHERE s.source_project = l.source_project AND s.source_table = l.source_table
+                        AND s.source_uuid = l.source_uuid
+                        AND s.id <> l.id AND s.status IN ('pending', 'skipped') AND to_regclass(s.target_table) IS NOT NULL) INTO v_retry_split;
+    END IF;
+    IF l.checksum = v_checksum AND NOT v_retry_split THEN
+      PERFORM migration._count(p_batch, 'skipped');
+      RETURN jsonb_build_object('status', 'skipped', 'reason', 'unchanged', 'target_table', l.target_table, 'target_id', l.target_id, 'ledger_id', l.id);
+    END IF;
+    IF l.checksum <> v_checksum AND migration.cursor_cmp(p_cursor, l.cursor) < 0 THEN
+      PERFORM migration._count(p_batch, 'skipped');
+      RETURN jsonb_build_object('status', 'skipped', 'reason', format('stale cursor: %s < %s already migrated', p_cursor, l.cursor),
+                                'target_table', l.target_table, 'target_id', l.target_id, 'ledger_id', l.id);
+    END IF;
+  END IF;
+
+  -- no writer yet: recorded, re-offered later
+  IF a.writer IS NULL THEN
+    UPDATE migration.ledger SET status = 'pending', reason = format('no destination writer for %s yet', v_target_table),
+           checksum = v_checksum, cursor = p_cursor, batch_id = p_batch WHERE id = l.id;
+    PERFORM migration._count(p_batch, 'pending');
+    RETURN jsonb_build_object('status', 'pending', 'reason', format('no destination writer for %s yet', v_target_table),
+                              'target_table', v_target_table, 'target_id', l.target_id, 'ledger_id', l.id);
+  END IF;
+
+  -- map + references
+  v_mapped := migration.map_row(b.source_project, p_source_table, p_row);
+  v_row := v_mapped -> 'row'; v_meta := v_mapped -> 'metadata'; v_unres := v_mapped -> 'unresolved';
+
+  -- Referência OPCIONAL: a que pode faltar sem que a linha perca o sentido.
+  --
+  -- Nem toda referência é identidade. A perna contábil de um movimento é
+  -- CLASSIFICAÇÃO: sem ela o dinheiro continua tendo valor, vencimento,
+  -- unidade e contraparte — tudo o que a tela de Contas a Receber mostra.
+  -- Recusar o movimento inteiro porque a classificação dele aponta para uma
+  -- conta que o próprio V1 apagou é perder o fato para preservar o rótulo.
+  --
+  -- Medido em 20/09/2026 no Espaço Facial: 81 das 84 contas do razão citadas
+  -- pelos movimentos recusados NÃO EXISTEM no V1. A referência já estava
+  -- quebrada na origem. Custo na tela: R$ 138.027 só no Millenium.
+  --
+  -- Quais colunas podem faltar é DECLARADO por tabela, em
+  -- `migration.allowlist.optional_refs` — nunca adivinhado. O que ficou sem
+  -- resolver vai para `metadata.migration.unresolved`: some da tela, não do
+  -- registro.
+  IF jsonb_array_length(v_unres) > 0 AND a.optional_refs IS NOT NULL THEN
+    -- O apelido é `ref`, e não `x`: `x` já é uma variável declarada nesta
+    -- função, e o Postgres recusa a ambiguidade em vez de escolher — com
+    -- razão.
+    v_meta := migration._deep_set(v_meta, ARRAY['migration', 'unresolved'],
+      coalesce((SELECT jsonb_agg(ref) FROM jsonb_array_elements(v_unres) AS ref
+                 WHERE ref ->> 'column' = ANY (a.optional_refs)), '[]'::jsonb));
+    v_unres := coalesce((SELECT jsonb_agg(ref) FROM jsonb_array_elements(v_unres) AS ref
+                          WHERE NOT (ref ->> 'column' = ANY (a.optional_refs))), '[]'::jsonb);
+  END IF;
+
+  IF jsonb_array_length(v_unres) > 0 THEN
+    RETURN migration._quarantine(l.id, p_batch, 'fk', 'unresolved reference(s): ' || v_unres::text, p_row);
+  END IF;
+
+  -- destination id (ADR 0007): the source uuid, else the id minted on the first offer
+  v_target_id := coalesce(l.target_id, p_source_uuid, gen_random_uuid());
+  v_meta := jsonb_set(v_meta, '{migration}', coalesce(v_meta -> 'migration', '{}'::jsonb) || jsonb_build_object(
+              'source_project', b.source_project, 'source_table', p_source_table, 'source_numeric_id', p_source_numeric_id,
+              'source_uuid', p_source_uuid, 'batch_id', p_batch), true);
+  v_row := v_row || jsonb_build_object('metadata', v_meta);
+  SELECT coalesce(jsonb_object_agg(c, v_row -> c), '{}'::jsonb) INTO v_fin FROM unnest(a.financial_columns) c WHERE v_row ? c;
+
+  -- As duas travas do corte. Em regime de espelho elas ficam de fora, e é a única
+  -- diferença de comportamento deste arquivo:
+  --
+  --   valor financeiro   o V1 é a fonte da verdade enquanto o V2 não escreveu;
+  --                      recusar a atualização deixaria o V2 com o preço velho de
+  --                      uma venda que foi corrigida ontem, em silêncio.
+  --   linha apagada      quem apaga no V2 durante o espelho é o retire_row, e ele
+  --                      marca o ledger como `retired`. Uma linha ainda
+  --                      `migrated` cujo destino sumiu foi apagada por fora — e
+  --                      recriá-la é justamente refletir o V1, que ainda a tem.
+  IF l.status = 'migrated' AND NOT v_mirror THEN
+    IF cardinality(a.financial_columns) > 0 THEN
+      v_dest := migration._destination_values(v_target_table, l.target_id, a.financial_columns);
+      IF v_dest IS NULL THEN
+        RETURN migration._quarantine(l.id, p_batch, 'state', 'target row no longer exists in the destination (deleted after migration); not re-created', p_row);
+      END IF;
+      FOREACH v_col IN ARRAY a.financial_columns LOOP
+        IF (v_row ? v_col) AND round(coalesce((v_row ->> v_col)::numeric, 0), 2) IS DISTINCT FROM round(coalesce((v_dest ->> v_col)::numeric, 0), 2) THEN
+          RETURN migration._quarantine(l.id, p_batch, 'value',
+            format('financial column %s: destination %s, incoming %s — an existing financial value is never overwritten', v_col, coalesce(v_dest ->> v_col, 'null'), coalesce(v_row ->> v_col, 'null')), p_row);
+        END IF;
+      END LOOP;
+    ELSIF migration._destination_values(v_target_table, l.target_id, ARRAY['id']) IS NULL THEN
+      RETURN migration._quarantine(l.id, p_batch, 'state', 'target row no longer exists in the destination (deleted after migration); not re-created', p_row);
+    END IF;
+  END IF;
+
+  -- delegate; any error is a state quarantine, never a partial write
+  BEGIN
+    -- Dispatch by name rather than by a CASE arm per writer. The CASE meant every
+    -- new destination writer had to re-emit this whole function, and a row naming
+    -- a writer the CASE did not list fell through to NULL — silently, which is
+    -- the failure mode this schema exists to prevent. The allowlist's CHECK is
+    -- the vocabulary, `migration` is definer-only, and the name is verified to
+    -- exist before it is called, so an allowlist row naming a writer nobody built
+    -- quarantines with that sentence instead of vanishing.
+    IF to_regprocedure(format('migration.upsert_%s(uuid,uuid,jsonb,jsonb)', a.writer)) IS NULL THEN
+      RETURN migration._quarantine(l.id, p_batch, 'state',
+        format('the allowlist names writer %L for %s, and migration.upsert_%s does not exist', a.writer, p_source_table, a.writer),
+        p_row, v_target_table);
+    END IF;
+    -- %I on the whole identifier, not on the suffix: format('upsert_%I', 'order')
+    -- yields upsert_"order", which is not the function's name.
+    EXECUTE format('SELECT migration.%I($1, $2, $3, $4)', 'upsert_' || a.writer)
+      INTO v_res USING b.tenant_id, v_target_id, v_row, a.writer_args;
+  EXCEPTION WHEN OTHERS THEN
+    v_res := jsonb_build_object('status', 'quarantined', 'kind', 'state', 'reason', format('%s: %s', SQLSTATE, SQLERRM));
+  END;
+  v_status := coalesce(v_res ->> 'status', 'quarantined');
+
+  IF v_status = 'quarantined' THEN
+    RETURN migration._quarantine(l.id, p_batch, coalesce(v_res ->> 'kind', 'state'), coalesce(v_res ->> 'reason', 'writer refused'), p_row);
+  END IF;
+  IF v_status = 'skipped' THEN
+    UPDATE migration.ledger SET status = 'skipped', reason = v_res ->> 'reason', checksum = v_checksum, cursor = p_cursor, batch_id = p_batch,
+           target_id = coalesce((v_res ->> 'target_id')::uuid, target_id) WHERE id = l.id;
+    PERFORM migration._count(p_batch, 'skipped');
+    RETURN jsonb_build_object('status', 'skipped', 'reason', v_res ->> 'reason', 'target_table', v_target_table, 'target_id', v_res ->> 'target_id', 'ledger_id', l.id);
+  END IF;
+
+  v_target_id := coalesce((v_res ->> 'target_id')::uuid, v_target_id);
+  UPDATE migration.ledger
+     SET status = 'migrated', target_table = v_target_table, target_id = v_target_id, checksum = v_checksum, cursor = p_cursor,
+         batch_id = p_batch, reason = v_res ->> 'reason', financial = nullif(v_fin, '{}'::jsonb)
+   WHERE id = l.id;
+  UPDATE migration.quarantine SET resolved_at = now(), resolution = 'row migrated on a later offer' WHERE ledger_id = l.id AND resolved_at IS NULL;
+
+  -- split rows (a Venda's invoice): one more ledger row per extra destination
+  FOR x IN SELECT value FROM jsonb_array_elements(coalesce(v_res -> 'extra', '[]'::jsonb)) LOOP
+    -- Mesma correção da sondagem de irmã, pelo mesmo motivo: com
+    -- IS NOT DISTINCT FROM nenhum dos dois índices da ledger é usado, e esta
+    -- busca acontece uma vez por destino extra de cada Venda.
+    IF p_source_numeric_id IS NOT NULL THEN
+      SELECT id INTO v_xid FROM migration.ledger
+       WHERE source_project = b.source_project AND source_table = p_source_table
+         AND source_numeric_id = p_source_numeric_id
+         AND target_table = x ->> 'target_table';
+    ELSE
+      SELECT id INTO v_xid FROM migration.ledger
+       WHERE source_project = b.source_project AND source_table = p_source_table
+         AND source_numeric_id IS NULL AND source_uuid = p_source_uuid
+         AND target_table = x ->> 'target_table';
+    END IF;
+    IF v_xid IS NULL THEN
+      INSERT INTO migration.ledger (source_project, source_table, source_numeric_id, source_uuid, tenant_id, target_table, target_id, checksum, cursor, batch_id, status, reason, financial)
+      VALUES (b.source_project, p_source_table, p_source_numeric_id, p_source_uuid, b.tenant_id, x ->> 'target_table', (x ->> 'target_id')::uuid,
+              v_checksum, p_cursor, p_batch, x ->> 'status', x ->> 'reason', nullif(x -> 'financial', 'null'::jsonb));
+    ELSE
+      UPDATE migration.ledger SET target_id = (x ->> 'target_id')::uuid, checksum = v_checksum, cursor = p_cursor, batch_id = p_batch,
+             status = x ->> 'status', reason = x ->> 'reason', financial = coalesce(nullif(x -> 'financial', 'null'::jsonb), financial) WHERE id = v_xid;
+    END IF;
+  END LOOP;
+
+  INSERT INTO public.audit_logs (tenant_id, user_id, action, entity_type, entity_id, metadata)
+  VALUES (b.tenant_id, NULL, 'migration.upsert', v_target_table, v_target_id::text,
+          jsonb_build_object('batch_id', p_batch, 'source_project', b.source_project, 'source_table', p_source_table,
+                             'source_numeric_id', p_source_numeric_id, 'source_uuid', p_source_uuid, 'reason', v_res ->> 'reason'));
+  PERFORM migration._count(p_batch, 'migrated');
+  RETURN jsonb_build_object('status', 'migrated', 'reason', v_res ->> 'reason', 'target_table', v_target_table, 'target_id', v_target_id,
+                            'ledger_id', l.id, 'merged', coalesce((v_res ->> 'merged')::boolean, false), 'extra', coalesce(v_res -> 'extra', '[]'::jsonb));
+END $function$
+
+;

package/migrations/076_o_desligado_tambem_precisa_atravessar.sql

@@ -0,0 +1,110 @@
+-- O desligado também precisa atravessar
+--
+-- `app_config()` filtrava `AND t.status = 'active' AND (expires_at IS NULL OR
+-- expires_at > now())`. Faz sentido para um cliente que lê "ausente =
+-- desligado" — e é exatamente o cliente que não podemos ter.
+--
+-- O shell resolve as ativações de forma ADITIVA: uma linha liga, uma linha
+-- `disabled` desliga, e um plugin que o banco nunca mencionou mantém o padrão
+-- do manifesto. Com o filtro, desligar um plugin o faz SUMIR da resposta — e
+-- sumir quer dizer "use o padrão", que é ligado. Desligar ligava.
+--
+-- O vencimento tem a mesma forma e é pior, porque acontece sozinho: no dia em
+-- que a cortesia vence a linha some e o plugin volta ligado para sempre.
+--
+-- Então a linha atravessa sempre, e o `status` que ela carrega é o EFETIVO —
+-- uma cortesia vencida chega como `disabled`, com o `expires_at` junto para
+-- quem quiser explicar por quê.
+--
+-- (Escrito sobre a versão da 008, que é a vigente. Uma primeira redação deste
+-- arquivo nasceu de uma cópia mais antiga, de um pool que ainda tinha o
+-- esquema `platform`, e trouxe de volta `platform.staff_role` e o aplicativo
+-- da casa — que a 002 já tinha removido da espinha. Num cluster novo isso é
+-- `schema "platform" does not exist`, e foi o que o encadeamento do zero
+-- acusou. Reescrever função a partir de cópia velha é como se perde o que
+-- alguém tirou de propósito.)
+--
+-- Idempotente: substitui uma função.
+
+CREATE OR REPLACE FUNCTION public.app_config() RETURNS jsonb
+    LANGUAGE plpgsql STABLE SECURITY DEFINER
+    SET search_path TO ''
+    AS $$
+DECLARE
+  v_tenant uuid := app.current_tenant_id();
+BEGIN
+  IF v_tenant IS NULL THEN
+    -- Fail closed and legibly: a caller with no resolvable tenant gets an empty
+    -- configuration, not somebody else's.
+    RETURN jsonb_build_object('tenant_id', NULL, 'plugins', '[]'::jsonb, 'nav', '[]'::jsonb, 'apps', '[]'::jsonb);
+  END IF;
+
+  RETURN jsonb_build_object(
+    'tenant_id', v_tenant,
+    'branding',  public.tenant_branding(),
+    'settings',  public.tenant_settings(),
+    'plugins', coalesce((
+      SELECT jsonb_agg(jsonb_build_object(
+               'plugin', t.plugin_id,
+               'facet',  nullif(t.facet, ''),
+               -- A verdade EFETIVA, não a coluna crua: uma cortesia vencida
+               -- vale desligada. E ela é REPORTADA, não escondida — esconder
+               -- a linha faz o cliente cair no padrão do manifesto, que é
+               -- ligado, e aí o vencimento LIBERA em vez de travar.
+               'status', CASE
+                           WHEN t.expires_at IS NOT NULL AND t.expires_at <= now() THEN 'disabled'
+                           ELSE t.status
+                         END,
+               'source', t.source,
+               'config', t.config,
+               'expires_at', t.expires_at
+             ) ORDER BY t.plugin_id, t.facet)
+        FROM app.tenant_plugins t
+       WHERE t.tenant_id = v_tenant
+    ), '[]'::jsonb),
+    -- The union across the caller's accounts. One row per app, however many of
+    -- the person's accounts run it.
+    'apps', coalesce((
+      SELECT jsonb_agg(x.obj ORDER BY x.sort_name)
+        FROM (
+          SELECT a.name AS sort_name,
+                 jsonb_build_object(
+                   'id',           a.id,
+                   'name',         a.name,
+                   'icon',         a.icon,
+                   'accent_color', a.accent_color,
+                   'url',          a.url,
+                   -- Where clicking lands. Staying in the active account wins;
+                   -- otherwise the first that runs it, ordered by name so the
+                   -- answer does not move between two identical calls.
+                   'tenant_id',    (array_agg(ta.tenant_id
+                                     ORDER BY (ta.tenant_id = v_tenant) DESC, tn.name))[1]
+                 ) AS obj
+            FROM app.tenant_apps ta
+            JOIN app.apps a       ON a.id  = ta.app_id
+            JOIN public.tenants tn ON tn.id = ta.tenant_id
+           WHERE ta.status = 'active'
+             AND a.active
+             AND ta.tenant_id IN (
+                   SELECT m.tenant_id FROM app.memberships m
+                    WHERE m.user_id = auth.uid() AND m.active)
+           GROUP BY a.id, a.name, a.icon, a.accent_color, a.url
+        ) x
+    ), '[]'::jsonb),
+    'nav', coalesce((
+      SELECT jsonb_agg(jsonb_build_object(
+               'key', n.entry_key, 'hidden', n.hidden, 'label', n.label,
+               'section', n.section, 'position', n.position
+             ) ORDER BY coalesce(n.position, 999), n.entry_key)
+        FROM app.tenant_nav n
+       WHERE n.tenant_id = v_tenant
+    ), '[]'::jsonb),
+    'permissions', coalesce((
+      SELECT jsonb_agg(DISTINCT rp.permission)
+        FROM app.memberships m
+        JOIN app.role_permissions rp ON rp.role_id = m.role_id AND rp.tenant_id = m.tenant_id
+       WHERE m.tenant_id = v_tenant AND m.user_id = auth.uid() AND m.active
+    ), '[]'::jsonb),
+    'generated_at', now()
+  );
+END $$;

package/migrations/077_a_unidade_escolhida_chega_ao_banco.sql

@@ -0,0 +1,128 @@
+-- A unidade escolhida chega ao banco.
+--
+-- No modo franquia, quem está em Vila Ema tem que ver as contas de Vila Ema.
+-- Não via: Financeiro → Contas a Pagar mostrava o tenant inteiro, e o mesmo
+-- valia para a receber, extrato, caixa e tudo o mais.
+--
+-- ── Onde estava o corte ─────────────────────────────────────────────────────
+--
+-- Três peças, e só a do meio faltava.
+--
+--   1. O APP já manda a unidade escolhida:
+--      `packages/admin/src/data/client.ts:83` acrescenta `x-fayz-unit` a toda
+--      requisição, e o cabeçalho está na lista de `vary` do dedupe.
+--
+--   2. O BANCO nunca leu esse cabeçalho. `app.current_unit_id()` lia SÓ a
+--      claim `unit_id` do JWT — que o GoTrue não emite. Resultado: a função
+--      devolvia NULL, "todas as unidades", sempre.
+--
+--   3. A RLS já sabia estreitar. `app.has_unit()` diz, na primeira linha:
+--          app.current_unit_id() IS NULL OR p_unit = app.current_unit_id()
+--      Com NULL eterno, o primeiro ramo era sempre verdadeiro.
+--
+-- O filtro do cliente (`packages/core/src/data/unit-scope.ts`) não cobre esse
+-- buraco, e o cabeçalho do próprio arquivo explica por quê: ele é um
+-- ESTREITAMENTO cosmético, aplicado só nos provedores genéricos de CRUD.
+-- Qualquer plugin que escreva a própria consulta passa por fora — e o
+-- financeiro inteiro escreve as dele. Medido: `resolveUnitScope` não aparece
+-- uma vez em `plugins/plugin-financial/src/data/supabase.ts`.
+--
+-- Por isso o conserto é aqui e não lá. No banco ele vale para toda tela de
+-- todo plugin, inclusive as que ainda não existem.
+--
+-- ── A função que faltava, e que o código já citava ──────────────────────────
+--
+-- `app.requested_tenant()` existe e lê `x-fayz-tenant`. O comentário DELA cita
+-- uma vizinha que nunca foi escrita:
+--
+--     -- Engole a falha de parse pela mesma razão que requested_unit(): uma
+--     -- função vizinha da RLS não é lugar de levantar exceção.
+--
+-- Esta migration escreve `app.requested_unit()`, na mesma forma, e liga
+-- `app.current_unit_id()` a ela.
+--
+-- ── O cabeçalho ESCOLHE, nunca CONCEDE ──────────────────────────────────────
+--
+-- Mesma disciplina de `current_tenant_id()`: a unidade pedida só vale se for
+-- uma que a pessoa já alcança (`app.user_unit_access`). Um cabeçalho apontando
+-- para unidade que não é sua NEGA — devolve o sentinela nulo, que não casa com
+-- unidade nenhuma — em vez de recuar para "todas". Recuar transformaria um
+-- pedido explícito e errado numa resposta silenciosa sobre a rede inteira, que
+-- é precisamente o que não pode acontecer numa franquia.
+--
+-- A verificação é uma sondagem na PK de `app.user_unit_access`
+-- (tenant_id, user_id, unit_id).
+--
+-- Idempotente.
+
+CREATE OR REPLACE FUNCTION app.requested_unit()
+ RETURNS uuid
+ LANGUAGE plpgsql
+ STABLE
+ SET search_path TO ''
+AS $function$
+DECLARE v text;
+BEGIN
+  v := nullif(current_setting('request.headers', true), '')::json ->> 'x-fayz-unit';
+  RETURN nullif(v, '')::uuid;
+-- Engole a falha de parse pela mesma razão que requested_tenant(): uma função
+-- vizinha da RLS não é lugar de levantar exceção.
+EXCEPTION WHEN OTHERS THEN RETURN NULL;
+END $function$;
+
+COMMENT ON FUNCTION app.requested_unit() IS
+  'A unidade que o app escolheu, pelo cabeçalho x-fayz-unit. Par de '
+  'app.requested_tenant(). Só diz o que foi PEDIDO — quem valida é '
+  'app.current_unit_id().';
+
+CREATE OR REPLACE FUNCTION app.current_unit_id()
+ RETURNS uuid
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO ''
+AS $function$
+DECLARE
+  v_jwt jsonb := coalesce(auth.jwt(), '{}'::jsonb);
+  v_raw text;
+  v_unit uuid;
+  v_uid uuid;
+BEGIN
+  -- ① a claim assinada, quando existir. Inalterado.
+  IF jsonb_exists(v_jwt, 'unit_id') THEN
+    v_raw := v_jwt ->> 'unit_id';
+    IF v_raw IS NULL OR v_raw !~* '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$' THEN
+      RETURN '00000000-0000-0000-0000-000000000000'::uuid;
+    END IF;
+    RETURN v_raw::uuid;
+  END IF;
+
+  -- ② o cabeçalho do app. Ele ESCOLHE entre as unidades que a pessoa já
+  -- alcança; não concede nenhuma.
+  v_unit := app.requested_unit();
+  IF v_unit IS NULL THEN
+    RETURN NULL;   -- "todas as unidades" — o seletor está em rede
+  END IF;
+
+  v_uid := auth.uid();
+  IF v_uid IS NULL THEN
+    RETURN '00000000-0000-0000-0000-000000000000'::uuid;
+  END IF;
+
+  IF EXISTS (SELECT 1 FROM app.user_unit_access a
+              WHERE a.tenant_id = app.current_tenant_id()
+                AND a.user_id = v_uid
+                AND a.unit_id = v_unit) THEN
+    RETURN v_unit;
+  END IF;
+
+  -- Pediu uma unidade que não é sua: nega. O sentinela não casa com unidade
+  -- nenhuma, então a tela vem vazia — que é a resposta certa, e muito melhor
+  -- que devolver a rede inteira.
+  RETURN '00000000-0000-0000-0000-000000000000'::uuid;
+END $function$;
+
+COMMENT ON FUNCTION app.current_unit_id() IS
+  'A unidade em foco: a claim assinada, senão o cabeçalho x-fayz-unit '
+  'validado contra app.user_unit_access. NULL = rede inteira. É o que faz '
+  'app.has_unit() estreitar, e por tabela nenhuma da RLS precisar saber que '
+  'existe um seletor de unidade na tela.';

package/migrations/078_onde_o_profissional_atende_atravessa.sql

@@ -0,0 +1,71 @@
+-- Onde o profissional atende atravessa.
+--
+-- A agenda de Vila Ema mostrava **24 profissionais**; o V1 diz que ali
+-- trabalham **5**. No Millenium eram **54** contra **11**. Uma agenda com
+-- cinco vezes mais colunas do que gente não está compartilhando ninguém — ela
+-- deixou de responder a pergunta que lhe fizeram.
+--
+-- ── Não é buraco de modelo: é de porte ──────────────────────────────────────
+--
+-- O V2 sabe dizer que alguém atende em várias unidades. A migration 020 já
+-- escreveu a resposta inteira, em `public.v_bookable_people`:
+--
+--     CASE WHEN p.unit_id IS NOT NULL THEN ARRAY[p.unit_id]
+--          ELSE (SELECT array_agg(g.subject_id) FROM app.resource_grants g
+--                 WHERE g.resource_type = 'people.person'
+--                   AND g.relation = 'available_in' …) END AS unit_ids
+--
+-- Uma unidade própria vai na coluna; várias vão em tuplas. E `NULL` é
+-- "ninguém disse" — deliberadamente diferente de "em todas".
+--
+-- O V1 também sabe: `professionals.units` é um array jsonb, com média de 2,77
+-- unidades por pessoa e máximo de 56.
+--
+-- O porte é que parou no meio. `upsert_person` faz a primeira metade — uma
+-- unidade vira `unit_id`, várias deixam `unit_id` nulo — e nunca escreveu as
+-- tuplas da segunda. Então quem trabalha em mais de uma loja chegava ao V2
+-- como "ninguém disse", e "ninguém disse" aparece em toda unidade.
+--
+-- ── O que esta migration faz ────────────────────────────────────────────────
+--
+-- Lê `metadata.professional.v1_unit_refs` — que o de-para já grava em toda
+-- pessoa vinda de `professionals` —, resolve cada id pelo ledger e escreve uma
+-- tupla `available_in` por unidade.
+--
+-- Os ids do V1 vêm misturados, uns como número e outros como texto (`["2"]` ao
+-- lado de `[520, 527]`). `jsonb_array_elements_text` normaliza os dois, e o
+-- `~ '^\d+$'` descarta o que não for id sem derrubar a linha.
+--
+-- Quem tem UMA unidade fica como está: a coluna já é a resposta completa, e
+-- escrever tupla para ela seria guardar a mesma informação em dois lugares.
+--
+-- Idempotente: `ON CONFLICT DO NOTHING` sobre a PK de `app.resource_grants`.
+
+INSERT INTO app.resource_grants
+  (tenant_id, resource_type, resource_id, relation, subject_type, subject_id)
+SELECT DISTINCT
+    p.tenant_id,
+    'people.person',
+    p.id,
+    'available_in',
+    'unit',
+    lu.target_id
+  FROM public.people p
+  JOIN migration.ledger lp
+    ON lp.target_id = p.id
+   AND lp.source_table = 'professionals'
+   AND lp.target_table = 'public.people'
+   AND lp.status = 'migrated'
+  CROSS JOIN LATERAL jsonb_array_elements_text(p.metadata #> '{professional,v1_unit_refs}') AS ref(v1)
+  JOIN migration.ledger lu
+    ON lu.tenant_id = p.tenant_id
+   AND lu.source_table = 'companies'
+   AND lu.target_table = 'app.units'
+   AND lu.status = 'migrated'
+   AND lu.source_numeric_id = ref.v1::bigint
+ WHERE jsonb_typeof(p.metadata #> '{professional,v1_unit_refs}') = 'array'
+   AND ref.v1 ~ '^\d+$'
+   -- Só quem NÃO tem coluna. Ver o CASE da 020: a coluna vence a tupla, então
+   -- escrever tupla para quem já tem unidade não muda nada e polui o registro.
+   AND p.unit_id IS NULL
+ON CONFLICT DO NOTHING;