ganbatte-os 0.2.20 → 0.2.21

package/.gos/plans/tasks/T-085-api-diagnostico-individual.md

@@ -0,0 +1,291 @@
+# T-085 — API Diagnóstico Individual (participante responde)
+
+**Sprint:** S07 · **Due:** 2026-04-19 · **Prioridade:** URGENT · **Pts:** 5
+**ClickUp:** https://app.clickup.com/t/86agn0217
+**Assignee:** Douglas Oliveira
+
+---
+
+## 🚫 [BLOCKED-PRD 2026-04-17] — Aguarda T-084 redesenhada + ajuste de status
+
+**Status:** BLOQUEADA.
+
+**Motivo:**
+1. Depende da T-084 redesenhada (tokens individuais gerados em novo fluxo).
+2. Status `selecionado` não existe mais no enum do PRD vigente. Transição correta é `pré-selecionado → cadastrado` (M2 em [impacto-tasks-clickup.md](../../../packages/fractus/docs/regras-de-negocio/impacto-tasks-clickup.md)).
+3. BR-PRT-003 precisa ser reescrita: `pré-selecionado → cadastrado` automático ao responder.
+4. PRD define **resposta como somente leitura após envio** (M7) — ajustar idempotência para rejeitar qualquer re-submissão, não apenas via UNIQUE.
+
+**Ações pendentes:**
+1. Substituir `status = 'selecionado'` por `status = 'cadastrado'` na RPC e no schema Zod (`statusParticipanteEnum`).
+2. Atualizar AC1 e AC2 com nomenclatura nova.
+3. Aguardar fechamento da T-084 redesenhada (tokens).
+4. Confirmar que auto-save de rascunho está fora do escopo (M8 — fora do MVP).
+
+**Referências:**
+- [packages/fractus/docs/prd.md](../../../packages/fractus/docs/prd.md) — §Tipos de status, §Respostas
+- [packages/fractus/docs/regras-de-negocio/impacto-tasks-clickup.md](../../../packages/fractus/docs/regras-de-negocio/impacto-tasks-clickup.md) — M1, M2, M4, M7, M8
+
+---
+
+## ⚠️ Pré-requisito bloqueante
+
+**T-084 DEVE estar fechada.** Este plano consome os `token_diagnostico` gerados pela RPC `submit_diagnostico_negocio`. Sem eles, não há lookup de participante por token.
+
+Validar: `psql -c "SELECT COUNT(*) FROM participantes WHERE token_diagnostico IS NOT NULL;"` retorna > 0.
+
+## Contexto
+
+Após T-084, cada participante pré-selecionado recebe um link individual:
+`/diagnostico/individual/[token]`. Ao clicar, vê formulário com as perguntas do projeto, responde e submete.
+
+**Fluxo:**
+1. Lookup participante por `token_diagnostico` (status deve ser `pre_selecionado`).
+2. Persistir respostas em `respostas_pesquisa` (uma linha por participante×instancia).
+3. Transição `participantes.status = 'selecionado'` (BR-PRT-003).
+4. Invalidar cache do projeto e do negócio.
+
+**Regras:**
+- BR-PRT-003: `pre_selecionado → selecionado` automática ao responder.
+- **Idempotência:** segundo submit com mesmo participante deve retornar 422 (evitar sobrescrita acidental).
+- Status ≠ `pre_selecionado` → 422 com código `INVALID_STATE`.
+
+## Arquivos afetados
+
+| Arquivo | Ação |
+|---|---|
+| `packages/fractus/src/lib/validations/diagnostico.ts` | [EDITAR] adicionar `submitIndividualSchema` |
+| `packages/fractus/src/app/actions/diagnostico/submit-individual.ts` | [NOVO] server action |
+| `packages/fractus/src/app/actions/diagnostico/submit-individual.test.ts` | [NOVO] testes |
+| `packages/fractus/src/app/diagnostico/individual/[token]/page.tsx` | [NOVO] página pública |
+| `packages/fractus/src/app/diagnostico/individual/[token]/form-client.tsx` | [NOVO] form |
+| `packages/fractus/supabase/migrations/2026041X_unique_resposta.sql` | [NOVO] UNIQUE (participante_id, instancia_id) |
+
+## Passo a passo
+
+### 0. Validar pré-requisito
+
+```bash
+cd packages/fractus
+psql "$DATABASE_URL" -c "SELECT COUNT(*) FROM participantes WHERE token_diagnostico IS NOT NULL AND status='pre_selecionado';"
+# Deve retornar > 0
+```
+
+### 1. Garantir idempotência no schema
+
+Migration `2026041X_unique_resposta.sql`:
+```sql
+ALTER TABLE respostas_pesquisa
+  ADD CONSTRAINT uniq_participante_instancia UNIQUE (participante_id, instancia_id);
+```
+
+### 2. Schema Zod
+
+Adicionar em `src/lib/validations/diagnostico.ts`:
+
+```ts
+export const submitIndividualSchema = z.object({
+  token: z.string().min(16),
+  instancia_id: z.string().uuid(),
+  respostas: z.array(z.object({
+    pergunta_id: z.string().uuid(),
+    valor: z.union([z.string(), z.number(), z.array(z.string())]),
+  })).min(1),
+})
+export type SubmitIndividualInput = z.infer<typeof submitIndividualSchema>
+```
+
+### 3. Server Action
+
+`src/app/actions/diagnostico/submit-individual.ts`:
+
+```ts
+'use server'
+
+import { headers } from 'next/headers'
+import { revalidatePath } from 'next/cache'
+import { createClient } from '@/lib/supabase/server'
+import { checkRateLimit } from '@/lib/rate-limit'
+import { submitIndividualSchema } from '@/lib/validations/diagnostico'
+
+type Result =
+  | { ok: true; participanteId: string }
+  | { ok: false; code: 'VALIDATION'|'NOT_FOUND'|'INVALID_STATE'|'ALREADY_SUBMITTED'|'RATE_LIMIT'|'ERROR'; message: string; fieldErrors?: Record<string,string[]> }
+
+export async function submitDiagnosticoIndividual(input: unknown): Promise<Result> {
+  const hdrs = await headers()
+  const ip = hdrs.get('x-forwarded-for')?.split(',')[0]?.trim() ?? 'unknown'
+  const rl = checkRateLimit(ip)
+  if (!rl.allowed) return { ok: false, code: 'RATE_LIMIT', message: `Tente em ${rl.retryAfterSeconds}s` }
+
+  const parsed = submitIndividualSchema.safeParse(input)
+  if (!parsed.success) {
+    return { ok: false, code: 'VALIDATION', message: 'Dados inválidos', fieldErrors: parsed.error.flatten().fieldErrors }
+  }
+
+  const supabase = await createClient()
+  const { token, instancia_id, respostas } = parsed.data
+
+  // 1. Lookup participante
+  const { data: p, error: pErr } = await supabase
+    .from('participantes')
+    .select('id, status, negocio_id, negocio:negocios(projeto_id)')
+    .eq('token_diagnostico', token)
+    .single()
+
+  if (pErr || !p) return { ok: false, code: 'NOT_FOUND', message: 'Link inválido' }
+  if (p.status !== 'pre_selecionado') {
+    return { ok: false, code: 'INVALID_STATE', message: 'Diagnóstico já respondido ou participante em estado inválido' }
+  }
+
+  // 2. RPC atômico: insert respostas + update status
+  const { error } = await supabase.rpc('submit_diagnostico_individual', {
+    p_participante_id: p.id,
+    p_instancia_id: instancia_id,
+    p_respostas: respostas,
+  })
+
+  if (error) {
+    if (error.code === '23505') {
+      return { ok: false, code: 'ALREADY_SUBMITTED', message: 'Diagnóstico já enviado' }
+    }
+    return { ok: false, code: 'ERROR', message: error.message }
+  }
+
+  revalidatePath(`/dashboard/projetos/${(p.negocio as any)?.projeto_id}`)
+  return { ok: true, participanteId: p.id }
+}
+```
+
+### 4. RPC Postgres
+
+```sql
+CREATE OR REPLACE FUNCTION submit_diagnostico_individual(
+  p_participante_id uuid,
+  p_instancia_id uuid,
+  p_respostas jsonb
+) RETURNS void
+LANGUAGE plpgsql SECURITY DEFINER AS $$
+DECLARE
+  v_r jsonb;
+BEGIN
+  -- Guardar snapshot das respostas
+  INSERT INTO respostas_pesquisa (participante_id, instancia_id, payload, respondido_em)
+  VALUES (p_participante_id, p_instancia_id, p_respostas, now());
+
+  UPDATE participantes SET status = 'selecionado' WHERE id = p_participante_id AND status = 'pre_selecionado';
+END;
+$$;
+```
+
+### 5. Página pública
+
+`src/app/diagnostico/individual/[token]/page.tsx`:
+
+```tsx
+import { notFound } from 'next/navigation'
+import { createClient } from '@/lib/supabase/server'
+import { FormClient } from './form-client'
+
+export default async function Page({ params }: { params: Promise<{ token: string }> }) {
+  const { token } = await params
+  const supabase = await createClient()
+  const { data } = await supabase
+    .from('participantes')
+    .select('id, nome, status, negocio:negocios(nome, projeto:projetos(id, nome, instancia_diagnostico_id))')
+    .eq('token_diagnostico', token)
+    .single()
+
+  if (!data) notFound()
+  if (data.status !== 'pre_selecionado') {
+    return <p className="p-8">Este diagnóstico já foi respondido.</p>
+  }
+
+  return <FormClient token={token} participante={data} />
+}
+```
+
+### 6. Testes
+
+- Token inexistente → `NOT_FOUND`
+- Status `ativo` → `INVALID_STATE`
+- Segundo submit com mesmo participante → `ALREADY_SUBMITTED` (UNIQUE)
+- Payload válido em primeiro submit → `ok: true` e status muda no banco
+
+## Critérios de aceite (literais)
+
+- **AC1:** Status muda para `selecionado`.
+- **AC2:** Participante com status diferente de `pre_selecionado` rejeitado.
+
+## Verificação end-to-end
+
+- [ ] `pnpm typecheck && pnpm lint && pnpm build` OK
+- [ ] Testes unitários verdes
+- [ ] Curl válido → `{ok:true}`, banco mostra status `selecionado`
+- [ ] Curl duplicado → `ALREADY_SUBMITTED`
+- [ ] Curl com participante `ativo` → `INVALID_STATE`
+- [ ] `pnpm dev` + navegar `/diagnostico/individual/<token>` com token válido → form
+
+## Entrega ao Douglas (**NÃO commitar, NÃO dar push**)
+
+> ⚠️ Dev NÃO commita.
+
+### Mensagem de commit sugerida
+
+```
+feat(diagnostico): API submit diagnóstico individual (idempotente)
+
+Refs T-085
+
+- AC1: status pre_selecionado → selecionado (RPC submit_diagnostico_individual)
+- AC2: status ≠ pre_selecionado retorna INVALID_STATE
+- UNIQUE (participante_id, instancia_id) em respostas_pesquisa (idempotência)
+- Rate limit 60/60s
+```
+
+## Rollback
+
+```bash
+git restore packages/fractus/src/lib/validations/diagnostico.ts
+rm -rf packages/fractus/src/app/actions/diagnostico/submit-individual*
+rm -rf packages/fractus/src/app/diagnostico/individual
+psql -c "DROP FUNCTION IF EXISTS submit_diagnostico_individual; ALTER TABLE respostas_pesquisa DROP CONSTRAINT IF EXISTS uniq_participante_instancia;"
+```
+
+## Dependências e bloqueios
+
+- **Upstream:** T-084 fechada (tokens gerados).
+- **Downstream:** T-086 (ativação manual depende de status `selecionado`).
+- **Risco:** tabela `instancias_pesquisa` precisa estar populada com perguntas. Se vazio, form não renderiza.
+
+## Checklist de entrega
+
+- [ ] T-084 confirmada fechada
+- [ ] AC1-AC2 validados
+- [ ] typecheck + lint + build OK
+- [ ] Testes unitários verdes
+- [ ] 3 cenários curl testados
+- [ ] `git status` + `git diff --stat` colados
+- [ ] **NÃO fiz commit nem push**
+- [ ] Douglas notificado
+
+## Checklist do Douglas
+
+- [ ] Revisar diff
+- [ ] Migration aplicada em staging
+- [ ] Smoke manual
+- [ ] Commit+push
+- [ ] ClickUp T-085 → `complete`
+
+## Evidência de entrega
+
+```
+# git status + diff --stat
+(output)
+
+# pnpm test
+(output)
+
+# 3 curls
+(output)
+```

package/.gos/plans/tasks/T-086-api-ativacao-manual-batch.md

@@ -0,0 +1,287 @@
+# T-086 — API Ativação Manual (gestor ativa participante em lote)
+
+**Sprint:** S07 · **Due:** 2026-04-19 · **Prioridade:** URGENT · **Pts:** 3
+**ClickUp:** https://app.clickup.com/t/86agn021d
+**Assignee:** Douglas Oliveira
+
+---
+
+## 🚫 [BLOCKED-PRD 2026-04-17] — Escopo invertido: ativação primária é automática
+
+**Status:** BLOQUEADA. Reavaliar escopo antes de executar.
+
+**Motivo:** O PRD vigente ([prd.md](../../../packages/fractus/docs/prd.md) §Tipos de status) determina que a **ativação é automática via presença em ≥1 oficina** — a ativação manual em lote deixa de ser fluxo principal e vira **exceção auditada** (BR-PRT-004 reinterpretada).
+
+Além disso, a transição correta é `cadastrado → ativo` (não `selecionado → ativo` — status `selecionado` foi removido, ver M2).
+
+**Ações pendentes:**
+1. Reduzir escopo: manter endpoint mas documentá-lo como exceção (não como feature principal).
+2. Trocar todas as refs a `status = 'selecionado'` por `status = 'cadastrado'` (AC1, AC2, RPC, testes).
+3. Adicionar auditoria obrigatória (log de quem ativou manualmente e quando) — PRD exige.
+4. Priorizar primeiro a task de ativação automática por presença (que ainda não existe em `.gos/plans/tasks/`).
+
+**Referências:**
+- [packages/fractus/docs/prd.md](../../../packages/fractus/docs/prd.md) — §Tipos de status, §Oficinas
+- [packages/fractus/docs/regras-de-negocio/impacto-tasks-clickup.md](../../../packages/fractus/docs/regras-de-negocio/impacto-tasks-clickup.md) — M2
+
+---
+
+## ⚠️ Pré-requisito bloqueante
+
+**T-085 DEVE estar fechada.** Este plano só faz sentido quando há participantes no status `selecionado` (output da T-085).
+
+Validar: `psql -c "SELECT COUNT(*) FROM participantes WHERE status='selecionado';"` retorna > 0.
+
+## Contexto
+
+Após o participante responder o diagnóstico (T-085), ele fica em `selecionado`. O **gestor do projeto** revisa os leads e decide quais promover para `ativo` (começam formalmente no programa). Essa ação é **manual e autenticada** — BR-PRT-004.
+
+**Fluxo:**
+1. Gestor autenticado abre `/dashboard/projetos/[id]/participantes`.
+2. Seleciona N participantes com checkbox (UI multi-select).
+3. Clica "Ativar selecionados" → chama server action `activateParticipants({ ids })`.
+4. Backend atualiza `status = 'ativo'` **apenas** onde `status = 'selecionado'` (idempotente).
+5. Retorna `{ activated, rejected }` — rejected = participantes em outros status.
+
+**Regras:**
+- BR-PRT-004: Transição para `ativo` requer ação manual.
+- Transição permitida: `selecionado → ativo`. Qualquer outro status → 422 por item.
+- Batch parcial é aceitável (UI mostra quais falharam).
+- Concorrência: dois gestores clicando simultaneamente — UPDATE idempotente via `WHERE status='selecionado'` resolve.
+
+## Arquivos afetados
+
+| Arquivo | Ação |
+|---|---|
+| `packages/fractus/src/app/actions/participants/activate.ts` | [NOVO] server action |
+| `packages/fractus/src/app/actions/participants/activate.test.ts` | [NOVO] testes |
+| `packages/fractus/src/components/domain/participants/activate-batch-button.tsx` | [NOVO] botão + confirm dialog |
+| `packages/fractus/src/components/domain/participants/participants-table.tsx` | [EDITAR] adicionar checkbox multi-select + botão |
+| `packages/fractus/src/lib/validations/participant.ts` | [EDITAR] adicionar `activateBatchSchema` |
+
+## Passo a passo
+
+### 0. Validar pré-requisito
+
+```bash
+psql "$DATABASE_URL" -c "SELECT status, COUNT(*) FROM participantes GROUP BY status;"
+# Deve ter pelo menos alguns 'selecionado' para testar
+```
+
+### 1. Schema Zod
+
+Em `src/lib/validations/participant.ts`:
+
+```ts
+export const activateBatchSchema = z.object({
+  participantIds: z.array(z.string().uuid()).min(1).max(100),
+})
+export type ActivateBatchInput = z.infer<typeof activateBatchSchema>
+```
+
+### 2. Server Action
+
+`src/app/actions/participants/activate.ts`:
+
+```ts
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { createClient } from '@/lib/supabase/server'
+import { activateBatchSchema } from '@/lib/validations/participant'
+
+type ItemResult = { id: string; ok: true } | { id: string; ok: false; code: 'INVALID_STATE'|'NOT_FOUND'; currentStatus?: string }
+
+type Result =
+  | { ok: true; activated: number; rejected: ItemResult[] }
+  | { ok: false; code: 'UNAUTHORIZED'|'VALIDATION'|'ERROR'; message: string; fieldErrors?: Record<string,string[]> }
+
+export async function activateParticipants(input: unknown): Promise<Result> {
+  // 1. Autenticação
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+  if (!user) return { ok: false, code: 'UNAUTHORIZED', message: 'Login obrigatório' }
+
+  // 2. Validação
+  const parsed = activateBatchSchema.safeParse(input)
+  if (!parsed.success) {
+    return { ok: false, code: 'VALIDATION', message: 'IDs inválidos', fieldErrors: parsed.error.flatten().fieldErrors }
+  }
+  const { participantIds } = parsed.data
+
+  // 3. Ler status atual de todos
+  const { data: current, error: readErr } = await supabase
+    .from('participantes')
+    .select('id, status, negocio:negocios(projeto_id)')
+    .in('id', participantIds)
+
+  if (readErr) return { ok: false, code: 'ERROR', message: readErr.message }
+
+  const currentMap = new Map(current?.map(p => [p.id, p]) ?? [])
+  const rejected: ItemResult[] = []
+  const eligible: string[] = []
+
+  for (const id of participantIds) {
+    const p = currentMap.get(id)
+    if (!p) { rejected.push({ id, ok: false, code: 'NOT_FOUND' }); continue }
+    if (p.status !== 'selecionado') {
+      rejected.push({ id, ok: false, code: 'INVALID_STATE', currentStatus: p.status })
+      continue
+    }
+    eligible.push(id)
+  }
+
+  // 4. Update idempotente (WHERE status='selecionado' previne race)
+  if (eligible.length > 0) {
+    const { error: updErr, count } = await supabase
+      .from('participantes')
+      .update({ status: 'ativo' }, { count: 'exact' })
+      .in('id', eligible)
+      .eq('status', 'selecionado')
+
+    if (updErr) return { ok: false, code: 'ERROR', message: updErr.message }
+
+    // 5. Revalidate paths dos projetos afetados
+    const projetoIds = [...new Set(current?.map(p => (p.negocio as any)?.projeto_id).filter(Boolean))]
+    projetoIds.forEach(pid => revalidatePath(`/dashboard/projetos/${pid}`))
+
+    return { ok: true, activated: count ?? 0, rejected }
+  }
+
+  return { ok: true, activated: 0, rejected }
+}
+```
+
+### 3. UI — Botão batch
+
+`src/components/domain/participants/activate-batch-button.tsx`:
+
+```tsx
+'use client'
+import { useState, useTransition } from 'react'
+import { Button } from '@/components/ui/button'
+import { ConfirmDialog } from '@/components/ui/confirm-dialog'
+import { toast } from 'sonner'
+import { activateParticipants } from '@/app/actions/participants/activate'
+
+export function ActivateBatchButton({ selectedIds, onDone }: { selectedIds: string[]; onDone: () => void }) {
+  const [open, setOpen] = useState(false)
+  const [pending, start] = useTransition()
+
+  const run = () => start(async () => {
+    const res = await activateParticipants({ participantIds: selectedIds })
+    if (!res.ok) { toast.error(res.message); return }
+    toast.success(`${res.activated} ativados${res.rejected.length ? `, ${res.rejected.length} rejeitados` : ''}`)
+    if (res.rejected.length) {
+      res.rejected.forEach(r => toast.warning(`${r.id}: ${r.code}${'currentStatus' in r ? ` (${r.currentStatus})` : ''}`))
+    }
+    setOpen(false); onDone()
+  })
+
+  return (
+    <>
+      <Button disabled={!selectedIds.length || pending} onClick={() => setOpen(true)}>
+        Ativar {selectedIds.length} selecionado{selectedIds.length !== 1 ? 's' : ''}
+      </Button>
+      <ConfirmDialog open={open} onOpenChange={setOpen} onConfirm={run}
+        title="Ativar participantes?"
+        description={`${selectedIds.length} serão promovidos para ativo. Apenas os em status 'selecionado' serão afetados.`} />
+    </>
+  )
+}
+```
+
+### 4. Integrar no ParticipantsTable
+
+Em `participants-table.tsx`:
+- Adicionar coluna checkbox (controlada via `selectedIds` state).
+- Header com "select all" para status `selecionado`.
+- Colocar `<ActivateBatchButton selectedIds={...} onDone={() => setSelectedIds([])} />` acima da tabela.
+
+### 5. Testes
+
+`activate.test.ts`:
+- Sem auth → `UNAUTHORIZED`
+- IDs válidos, todos `selecionado` → `activated = N, rejected = []`
+- Mix: 2 `selecionado` + 1 `pre_selecionado` + 1 `ativo` → `activated = 2, rejected.length = 2`
+- ID inexistente → rejected com `NOT_FOUND`
+- Payload vazio → `VALIDATION`
+
+## Critérios de aceite (literais)
+
+- **AC1:** Gestor ativa de `selecionado` para `ativo`.
+- **AC2:** Status diferente de `selecionado` retorna 422 (no contexto de server action: `rejected[].code = 'INVALID_STATE'`).
+- **AC3:** Ativação em lote funcional.
+
+## Verificação end-to-end
+
+- [ ] `pnpm typecheck && pnpm lint && pnpm build` OK
+- [ ] Testes unitários verdes (5 cenários)
+- [ ] Smoke manual: logar como gestor, ir em `/dashboard/projetos/[id]/participantes`, selecionar 3 (mix de status), clicar ativar, ver toast com `activated: 2, rejected: 1` (ajustar conforme fixtures)
+- [ ] Banco: participantes `selecionado` viraram `ativo`; outros intocados
+- [ ] Toast mostra falhas por item
+
+## Entrega ao Douglas (**NÃO commitar, NÃO dar push**)
+
+> ⚠️ Dev NÃO commita.
+
+### Mensagem de commit sugerida
+
+```
+feat(participants): ativação manual em lote (selecionado → ativo)
+
+Refs T-086
+
+- AC1: gestor ativa via server action activateParticipants
+- AC2: status ≠ selecionado rejected com INVALID_STATE + currentStatus
+- AC3: batch com UI multi-select + ConfirmDialog
+- Auth obrigatória (supabase.auth.getUser)
+- Update idempotente (WHERE status='selecionado') protege contra race
+```
+
+## Rollback
+
+```bash
+rm -f packages/fractus/src/app/actions/participants/activate*
+rm -f packages/fractus/src/components/domain/participants/activate-batch-button.tsx
+git restore packages/fractus/src/components/domain/participants/participants-table.tsx
+git restore packages/fractus/src/lib/validations/participant.ts
+```
+
+## Dependências e bloqueios
+
+- **Upstream:** T-085 fechada (participantes em `selecionado`).
+- **Downstream:** fluxo de presença (T-053 futura) pode filtrar só `ativo`.
+- **Risco:** se `ConfirmDialog` ainda não existir (T-014 em andamento), fazer fallback com `window.confirm` temporariamente e documentar no plano.
+
+## Checklist de entrega
+
+- [ ] T-085 confirmada fechada
+- [ ] AC1-AC3 validados
+- [ ] typecheck + lint + build OK
+- [ ] 5 cenários de teste verdes
+- [ ] Smoke manual no dashboard
+- [ ] `git status` + `git diff --stat` colados
+- [ ] **NÃO fiz commit nem push**
+- [ ] Douglas notificado
+
+## Checklist do Douglas
+
+- [ ] Revisar diff (UI + action)
+- [ ] Smoke manual com usuário real autenticado
+- [ ] Commit+push
+- [ ] ClickUp T-086 → `complete`
+- [ ] Sprint S07 fechada se esta for a última
+
+## Evidência de entrega
+
+```
+# git status + diff --stat
+(output)
+
+# pnpm test activate
+(output)
+
+# smoke manual (screenshot ou texto)
+(output)
+```