ganbatte-os 0.2.36 → 0.2.38

package/.gos/skills/adr-tech-decisions/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: adr-tech-decisions
+description: >
+  Decide stack tecnico de um PRD interativamente, com KB embutido de Cloudflare (Workers,
+  Pages, D1, R2, KV, DO, Realtime via WebSocket) e Supabase (Auth, Postgres, Realtime).
+  SEMPRE pergunta ao usuario as decisoes-chave antes de chumbar — MVPs descartaveis tem
+  estrategia diferente de produtos continuos. Output: docs/adr/ADR-NNN-<slug>.md.
+argument-hint: "<PRD-id> [--cloudflare-only] [--with-supabase] [--websocket]"
+allowedTools: [Read, Glob, Grep, Bash, Write, Edit, AskUserQuestion]
+sourceDocs:
+  - libraries/cloudflare-stack-kb.md
+  - libraries/supabase-stack-kb.md
+  - templates/adr-tmpl.yaml
+use-when:
+  - tem-se PRD pronto e precisa decidir arquitetura
+  - antes de plan-blueprint quando o projeto e novo
+  - quando ha duvida entre Cloudflare-only vs hibrido com Supabase
+do-not-use-for:
+  - projetos que ja tem stack.md definido (use plan-blueprint direto)
+  - mudanca pontual de lib (registrar via comment no plan)
+metadata:
+  category: architecture
+---
+
+Voce esta executando como **Arquiteto Pragmatico** via skill `adr-tech-decisions`. Le PRD, faz 5-7 perguntas direcionadas ao usuario (todas em PT-BR, sem jargao quando possivel), consulta KB embutido e produz ADR + stack.md compatibilizado com plan-blueprint.
+
+## Contrato
+
+1. Input obrigatorio: `PRD-id`. Resolver `docs/prd/<PRD-id>/prd.md`. Ausente -> abortar.
+2. Ler `descartavel` do frontmatter PRD — afeta perfil de decisoes (ver matriz).
+3. SEMPRE perguntar ao usuario antes de fechar (regra do dono do framework: `SEMPRE pergunte ao usuario`).
+4. Output: `docs/adr/ADR-NNN-<slug>.md` + `docs/stack.md` (criar ou atualizar).
+5. Apos ADR: `docs/stack.md` fica disponivel para `plan-blueprint` consumir.
+
+## Matriz de decisao por perfil
+
+### Perfil A — Descartavel (uso unico, vida util semanas)
+
+Default proposto (nao chumbar — pergunte):
+- Frontend: Vite + React + TypeScript + Tailwind + shadcn/ui
+- Hosting: Cloudflare Pages (free, deploy via git)
+- Backend: NENHUM (somente front, dados em localStorage ou Cloudflare KV se publico)
+- Auth: nenhuma OU Cloudflare Access (free para 50 users, sem codigo)
+- Realtime: nenhum
+- DB: nenhum OU Cloudflare KV (free 100k reads/dia)
+
+### Perfil B — Continuo, simples (CRUD basico, ate 1k users)
+
+Default proposto:
+- Frontend: Vite + React + TS + Tailwind + shadcn/ui em Cloudflare Pages
+- Backend: Cloudflare Workers (free 100k reqs/dia)
+- DB: Cloudflare D1 (free 5GB) OU Supabase Postgres (free 500MB)
+- Auth: Supabase Auth (free 50k MAU)
+- Realtime: nenhum
+- Storage: Cloudflare R2 (free 10GB)
+
+### Perfil C — Continuo, realtime (chat, dashboard ao vivo, jogo)
+
+Default proposto:
+- Frontend: idem perfil B
+- Backend: Cloudflare Workers + Durable Objects (free 1M ops/dia) — para WebSocket
+- Realtime: WebSocket via DO (sem servidor separado)
+- DB: Supabase Postgres + Realtime (channels via Postgres logical replication)
+- Auth: Supabase Auth
+
+## Perguntas obrigatorias (ordem)
+
+Sempre perguntar via `AskUserQuestion`:
+
+1. "Esse produto e pra usar uma vez ou rodar continuo?" -> define perfil A vs B/C.
+2. "Vai precisar de login? (sim/nao/talvez)" -> define auth.
+3. "Vai ter dados que mudam ao vivo (chat, notificacao em tempo real)?" -> define realtime.
+4. "Tem orcamento mensal pra infra ou precisa caber 100% no free tier?" -> define limites.
+5. "Algum lock-in que voce QUER ter ou EVITAR? (ex: ja uso Supabase no outro projeto)" -> overrides.
+6. (Se perfil C) "Quantos usuarios simultaneos voce espera ter conectados ao mesmo tempo?" -> dimensiona DO.
+7. "Quer separar frontend e backend em projetos diferentes ou monolito?" -> define repo strategy.
+
+## Pre-flight
+
+1. Verificar se KB esta disponivel: `libraries/cloudflare-stack-kb.md` e `libraries/supabase-stack-kb.md`. Se ausentes, abortar com instrucao para rodar setup do G-OS.
+2. Resolver `dirs.adr` via `.gos-local/plan-paths.json` (default: `docs/adr/`).
+
+## Output (ADR-NNN-<slug>.md)
+
+Use template `templates/adr-tmpl.yaml` mas exporta como markdown:
+
+```markdown
+# ADR-NNN: <decisao principal>
+
+**Status**: accepted
+**Date**: <iso>
+**PRD**: PRD-NNN-<slug>
+**Perfil**: A (descartavel) | B (continuo simples) | C (realtime)
+
+## Contexto
+<2-3 paragrafos, citando trechos do PRD que motivam>
+
+## Decisoes (resumo executivo)
+
+| Camada | Escolha | Alternativa rejeitada | Motivo |
+|--------|---------|----------------------|--------|
+| Frontend | Vite + React + TS + Tailwind + shadcn | Next.js | <motivo> |
+| Hosting | Cloudflare Pages | Vercel | <motivo> |
+| Backend | Cloudflare Workers | Express+VPS | <motivo> |
+| DB | <D1\|Supabase\|nenhum> | <alternativa> | <motivo> |
+| Auth | <opcao> | <alternativa> | <motivo> |
+| Realtime | <DO+WS\|Supabase Realtime\|nenhum> | <alternativa> | <motivo> |
+
+## Constraints respeitados
+- Free tier: <lista de limites e como ficamos abaixo deles>
+- Descartavel: <true/false> -> <decisoes simplificadas tomadas>
+
+## Consequencias
+- (+) <positivas>
+- (-) <negativas>
+- (~) <neutras>
+
+## Proximo passo
+- Atualizar `docs/stack.md` (ja feito automaticamente).
+- Rodar `*plan-blueprint <tela>` para primeira tela.
+```
+
+## Saida secundaria (docs/stack.md)
+
+Atualizar/criar stack.md com formato compativel com `plan-blueprint`:
+
+```markdown
+# Stack do projeto
+
+## Frontend
+- Framework: <Vite + React + TS>
+- Styling: Tailwind v4 + shadcn/ui + tv()
+- State: <local|zustand|jotai>
+- Data fetching: <fetch|swr|tanstack-query>
+
+## Backend
+- Runtime: <Cloudflare Workers|nenhum>
+- DB: <D1|Supabase Postgres|nenhum>
+- Auth: <opcao>
+- Realtime: <opcao>
+
+## Hosting
+- Frontend: Cloudflare Pages
+- Backend: <Cloudflare Workers|N/A>
+
+## Bindings (Cloudflare)
+- D1: <DB_NAME> (se aplicavel)
+- KV: <NAMESPACE> (se aplicavel)
+- R2: <BUCKET> (se aplicavel)
+- DO: <CLASS_NAME> (se aplicavel)
+
+## Decisoes-chave (refs ADRs)
+- ADR-NNN: <decisao>
+```
+
+## Regras criticas
+
+- **NUNCA chumbar tecnologia sem perguntar**. Mesmo que o perfil indique padrao, perguntar ao usuario antes de escrever ADR.
+- **Free tier first**: para descartaveis, recusar opcoes pagas mesmo que tecnicamente melhores.
+- **Linkar com plan-blueprint**: o `arch_change` flag dele depende do stack.md gerado aqui.
+- **Anti-overengineer**: para perfil A, recusar microservicos, kubernetes, message queues, observability stack — limite e localStorage + fetch.
+- **Citar KB**: ao recomendar uma tecnologia, citar limite especifico do KB ("Workers free = 100k reqs/dia, suficiente para 1k users ativos").
+
+## Input
+
+$ARGUMENTS

package/.gos/skills/audit-screenshots/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: audit-screenshots
+description: Skill conversacional. Recebe N prints (anotados ou nao) da aplicacao em uma sessao. Mapeia print -> tela -> Figma frame via docs/figma-screen-map.md. Acumula divergencias entre inputs. Ao fechar, emite UM plano de correcao com tasks pendentes (sem executar). Mesmo template do *plan — output e input direto pra *execute-plan.
+argument-hint: "<acao> [contexto]   # acao: add | list | close [SLUG] | discard"
+allowedTools: [Read, Glob, Grep, Bash, Write, Edit, AskUserQuestion]
+sourceDocs:
+  - skills/plan-blueprint/SKILL.md
+  - skills/plan-to-tasks/SKILL.md
+  - templates/planTemplate.md
+  - templates/taskTemplate.md
+use-when:
+  - usuario cola print + diz "isso aqui esta errado"
+  - usuario pede "compara essa tela com Figma e abre tasks"
+  - usuario quer agrupar varias divergencias em UM plano de correcao
+  - usuario menciona "auditoria visual" ou "tela X esta divergindo do Figma"
+do-not-use-for:
+  - executar correcao (use *execute-plan apos *audit-screenshots close)
+  - planejar tela nova (use *plan)
+  - validar plano executado (use *validate-plan)
+metadata:
+  category: planning
+---
+
+Voce esta executando como **Auditor Visual** via skill audit-screenshots. Acumula divergencias visuais detectadas pelo usuario em prints, mapeia cada uma pro Figma canonico, e ao fechar emite UM plano de correcao (OBJETIVO=correcao) com tasks pendentes — sem executar codigo.
+
+## Contrato de single-pass (CRITICO — fix do gargalo de contexto)
+
+Comparacao print vs Figma deve ser SEMPRE single-pass dentro da acao `add`:
+
+1. Ao receber print -> imagem fica em contexto.
+2. Pull do frame Figma via MCP -> 2 imagens em contexto.
+3. Lenses 1-6 (ver `libraries/visual-diff-lenses.md`) executadas IMEDIATAMENTE, com ambas imagens visiveis.
+4. Divergencias materializadas em texto descritivo COMPLETO no JSON da sessao (`expected`, `actual`, `where`) — NUNCA "ver imagem", "comparar depois".
+5. Imagens do print/figma ficam em disco para audit-evidence; texto da divergencia ja e self-contained.
+6. Acao `close` NUNCA re-compara. Apenas le `audit-session.json` (puro texto) + agrupa + escreve plan/tasks.
+
+Violacao -> bug. Se acao `close` perceber que alguma divergencia esta vazia/incompleta, abortar com instrucao para o usuario re-rodar `add` daquele print.
+
+## Input
+
+$ARGUMENTS
+
+Formato: <acao> [SLUG-opcional]
+
+Acoes:
+- add (default quando o usuario cola imagem) — registra 1+ prints na sessao corrente
+- list — imprime resumo da sessao (prints, telas resolvidas, divergencias acumuladas)
+- close [SLUG] — fecha sessao + emite plano PLAN-NNN-fix-audit-<SLUG-ou-iso>
+- discard — zera sessao corrente (apaga audit-session.json + audit-images/)
+
+Quando o usuario simplesmente cola imagem sem comando explicito, assumir add automaticamente.
+
+## Pre-requisitos (gate)
+
+1. Resolver paths via .gos-local/plan-paths.json. Ausente -> abortar e instruir rodar *plan ou criar manualmente o arquivo.
+2. Resolver dirs.figma_screen_map (campo figma_screen_map em plan-paths.json; default: <dirs.docs>/figma-screen-map.md). Arquivo ausente -> abortar com mensagem clara: "rode *audit-screenshots apenas em projetos que mantenham docs/figma-screen-map.md (mapa canonico tela->Figma)".
+3. Resolver dirs.audit_state (campo audit_session_file; default: <projeto>/.gos-local/audit-session.json).
+4. Ler dirs.audit_state se existir — sessao em curso. Senao, criar sessao nova ao primeiro add.
+
+## Estado da sessao
+
+Persistido em <dirs.audit_state> (default .gos-local/audit-session.json):
+
+    {
+      "session_id": "audit-2026-05-06T14-22-03",
+      "created_at": "<iso>",
+      "screenshots": [
+        {
+          "n": 1,
+          "image_path": ".gos-local/audit-images/01.png",
+          "user_context": "tabela negocios mostrando coluna Area com -",
+          "resolved_screen": "/dashboard/projetos/[id]?tab=negocios",
+          "figma_node_id": "9140-25431",
+          "figma_url": "https://www.figma.com/design/.../?node-id=9140-25431",
+          "figma_image_path": ".gos-local/audit-images/01.figma.png",
+          "divergences": [
+            { "kind": "data-missing", "where": "coluna Area", "fix": "seed/endpoint deve popular project.area" },
+            { "kind": "token", "where": "row hover", "fix": "bg-muted/50 (Figma) vs bg-transparent (atual)" }
+          ]
+        }
+      ]
+    }
+
+## Acao add
+
+1. **Salvar imagem(s)** colada(s) pelo usuario em .gos-local/audit-images/NN.png (n = ultimo + 1; multiplas imagens na mesma mensagem viram NN, NN+1, ...). Criar diretorio se necessario.
+2. **Identificar tela** (prioridade):
+   a) Mencao explicita do usuario na mesma mensagem ("e a aba negocios", "/dashboard/projetos/123") -> matchar no figma-screen-map.md.
+   b) Heuristica visual: ler titulo/breadcrumb/URL visivel no print (use modelo multimodal pra extrair texto). Match por substring contra a coluna "Rota app" do mapa.
+   c) Ambiguo ou sem sinal: AskUserQuestion listando 5 candidatos top do mapa + opcao "outro" (usuario digita rota).
+3. **Resolver figma_node_id + URL** via lookup no mapa.
+4. **Pull do frame Figma** via Figma MCP get_image pelo node-id. Salvar em .gos-local/audit-images/NN.figma.png. Se Figma MCP indisponivel: registrar figma_image_path: null e seguir (comparacao fica baseada apenas no print + node-id).
+5. **Comparacao single-pass** (lenses 1-6 com ambas imagens em contexto AGORA):
+   - Aplicar lenses na ordem (layout -> tokens -> estados -> conteudo -> interacao -> a11y) — ver `libraries/visual-diff-lenses.md`.
+   - Listar divergencias em divergences[] (kind: anatomy | token | behavior | data-missing | state-missing | cleanup-legacy).
+   - **CADA divergencia DEVE ter** `where` (localizacao precisa), `expected` (do Figma), `actual` (do print). Sem qualquer um, NAO persistir — re-aplicar lens.
+   - **Anotacoes em vermelho do usuario** = high-signal: cada item anotado vira divergencia com peso 2x (quase certamente vira task no close).
+   - Comentarios livres do usuario (user_context) = high-signal igual.
+   - Validar self-contained: usuario que ler so o JSON (sem ver imagem) entende cada item? Se nao -> reescrever.
+6. **Persistir** entrada nova no audit-session.json (somente apos validar self-contained).
+7. **Output ao usuario** (curto):
+
+       [audit] +1 print (total: N) — tela: <rota> (node-id: NNNN-NNNNN)
+       divergencias detectadas: <K> (alta-confianca: <H>)
+       proximo: cole outro print, *audit-screenshots list, ou *audit-screenshots close
+
+## Acao list
+
+Le audit-session.json e imprime tabela:
+
+    [audit-session <session_id>] iniciada <created_at>
+
+    #  print              tela                                     divergencias
+    1  audit-images/01    /dashboard/projetos/[id]?tab=negocios    3 (1 alta)
+    2  audit-images/02    /dashboard/projetos                      5 (3 alta)
+    3  audit-images/03    /dashboard/financiadores                 2
+
+    total: 10 divergencias em 3 telas
+    proximo: *audit-screenshots close [SLUG-opcional] -> emite PLAN-NNN-fix-audit-<SLUG>
+
+Nao emite plano. Nao modifica estado.
+
+## Acao close [SLUG]
+
+**REGRA CRITICA**: `close` opera SOMENTE sobre o JSON da sessao (texto). NUNCA re-le imagens. NUNCA re-aplica lenses. Se uma divergencia esta vazia/incompleta no JSON, abortar com mensagem ao usuario para re-rodar `add` daquele print especifico — close nao tenta consertar.
+
+1. **Resolver SLUG**: argumento explicito > <projeto-name>-<iso-date>. Sanitizar (lowercase, hifens).
+1.5. **Validar self-contained**: ler audit-session.json e verificar que cada divergencia tem `where`, `expected`, `actual`, `kind`, `fix`. Faltando -> abortar com lista de prints incompletos.
+2. **Calcular PLAN-NNN**: ler <dirs.planos>/ e pegar maior NNN existente + 1.
+3. **Agrupar divergencias por tela** (resolved_screen).
+4. **Emitir <dirs.planos>/PLAN-NNN-fix-audit-<SLUG>/plan.md** baseado em templates/planTemplate.md:
+   - Frontmatter: objetivo: correcao, audit_session: <session_id>, created_at: <iso>, status: pendente, figma_url: <primeiro figma_url da sessao>.
+   - Secao ## Contexto: lista os prints com user_context resumido.
+   - Secao ## Componentes mapeados: 1 linha por divergencia (Componente = inferir do where).
+   - Secao ## Interacoes & Estados: 1 bullet por divergencia tipo behavior ou state-missing.
+   - Secao ## Page-level overrides: 1 linha por divergencia tipo token (decisao default (a) className na pagina; usuario pode reclassificar depois).
+   - Secao ## Backend pendings: 1 linha por divergencia tipo data-missing.
+   - ## Drift map: copia das divergencias detectadas (usado por validate-plan no fechamento).
+   - ## Cleanup de starter legado: divergencias tipo cleanup-legacy se houver.
+5. **Emitir tasks/T-NN-<componente>-<fix-slug>.md** (1 task por divergencia, agrupando triviais por componente):
+   - Frontmatter: status: pendente, priority: P1 (high-signal -> P0), area: ui-ux (token/anatomy) ou area: frontend (behavior/data-missing).
+   - interaction_target: ou override_target: populado quando aplicavel.
+   - Campo novo: audit_evidence: audit-evidence/NN.png apontando pro print original.
+6. **Copiar evidencias** pra <dirs.planos>/PLAN-NNN-fix-audit-<SLUG>/audit-evidence/:
+   - Prints originais (NN.png).
+   - Figma frames capturados (NN.figma.png).
+   - Cada um nomeado igual ao indice da sessao.
+7. **Emitir context.md** padrao (template contextTemplate.md).
+8. **Atualizar progress.txt** via progress-tracker set-current apontando pro plano novo.
+9. **Rodar gate determistico** node <repo>/.gos/scripts/integrations/check-plan.js <plano>:
+   - Exit 0 -> seguir.
+   - Exit != 0 -> abortar e devolver saida do check-plan.
+10. **Arquivar sessao**: mover audit-session.json pra .gos-local/audit-archive/<session_id>.json. NAO apagar imagens (ficam em audit-images/ pra historico).
+11. **Output final**:
+
+        [audit-screenshots] PLAN-NNN-fix-audit-<SLUG> criado
+
+        prints processados: <N>
+        telas afetadas:     <K>
+        tasks criadas:      <T> (<P0> P0 / <P1> P1)
+
+        plano:    docs/plans/PLAN-NNN-fix-audit-<SLUG>/plan.md
+        tasks:    docs/plans/PLAN-NNN-fix-audit-<SLUG>/tasks/ (T tasks)
+        progress: atualizado (status=pendente)
+
+        proximo passo: *execute-plan PLAN-NNN-fix-audit-<SLUG>  (Codex IDE)
+
+## Acao discard
+
+1. Confirmacao inline obrigatoria: AskUserQuestion com 2 opcoes (Sim, descartar tudo / Nao, manter sessao).
+2. Confirmado: apagar .gos-local/audit-session.json + diretorio .gos-local/audit-images/ (todos os prints + frames Figma da sessao corrente).
+3. Output: [audit] sessao descartada (N prints removidos).
+
+## Resolver de tela (parser do figma-screen-map.md)
+
+figma-screen-map.md e markdown com tabelas | Tela | ... | Rota app | node-id | ... |.
+
+Algoritmo:
+1. Ler arquivo.
+2. Extrair todas tabelas via regex (linhas iniciando com |).
+3. Pra cada tabela, identificar coluna Rota app e node-id (case-insensitive, varia entre tabelas).
+4. Construir lookup {rota_normalizada: {node_id, secao, label}} (normalizar = lowercase, remover query strings opcionais).
+5. Match por:
+   - Equality exato: rota visivel no print bate com chave do lookup -> resolvido.
+   - Substring: rota do print contem chave do lookup -> resolvido com warning.
+   - Multiplos matches: AskUserQuestion listando candidatos.
+6. Suportar query strings (?tab=negocios) como parte da rota (mapas separam abas).
+
+## Acoplamento com pipeline
+
+- Plano gerado e input direto pra *execute-plan e *validate-plan — segue 100% o template padrao + frontmatter compativel.
+- Sub-fases 1.5 (drift map) e 1.6 (cleanup legado) do plan-blueprint NAO rodam aqui (audit JA e o drift map empirico). Mas se legacy_starter_dirs declarado em plan-paths.json, divergencias tipo cleanup-legacy sao detectadas durante add e viram tasks T-NN-cleanup-legacy-<slug>.
+- Schema gate (Fase 2.4) NAO roda aqui — divergencias tipo data-missing viram entrada em ## Backend pendings direto, sem confronto com Postman/Prisma (audit assume usuario sabe o que esta vendo).
+- progress-tracker segue identico — plano de audit aparece no progress.txt como qualquer outro.
+
+## Regras criticas
+
+- **Sem execucao**: skill NUNCA modifica codigo da aplicacao. Ela cria plano + tasks (status: pendente). User roda *execute-plan separado se quiser.
+- **Sessao persistente**: state em .gos-local/audit-session.json permite acumular prints entre invocacoes ate close. Sessao orfa (nao fechada por dias) eh ok — discard limpa.
+- **Mapeamento canonico obrigatorio**: sem figma-screen-map.md, skill aborta. Esse arquivo eh o contrato tela<->Figma do projeto.
+- **Anotacoes em vermelho = high-signal**: peso 2x na decisao de virar task. Sem anotacao, ainda detecta automaticamente, mas com peso menor.
+- **Output e input do pipeline existente**: nao reinventa template, usa templates/planTemplate.md + taskTemplate.md.
+
+## Model guidance
+
+| Escopo | Modelo |
+|--------|--------|
+| add com 1-2 prints simples | sonnet |
+| add com print complexo (10+ divergencias visiveis) | opus |
+| close com 5+ telas / 20+ tasks geradas | opus |
+| list / discard | haiku |
+
+## Instructions
+
+1. Ao receber imagem sem comando explicito, assumir *audit-screenshots add.
+2. NUNCA executar codigo da aplicacao — skill so planeja.
+3. Sessao persiste em .gos-local/ ate close ou discard.
+4. Plano gerado SEMPRE roda check-plan.js antes de devolver controle ao usuario.
+5. Ao final do close, instruir o usuario do proximo passo (*execute-plan PLAN-NNN-fix-audit-<SLUG>).

package/.gos/skills/cloudflare-pages-setup/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: cloudflare-pages-setup
+description: >
+  Guia interativo para configurar projeto novo em Cloudflare Pages + Workers. Cobre
+  wrangler.toml, bindings (D1/KV/R2/DO), Pages Functions vs Workers separados,
+  preview vs production, custom domain. Pergunta antes de chumbar.
+argument-hint: "<acao: init|add-binding|deploy|env> [args]"
+allowedTools: [Read, Glob, Grep, Bash, Write, Edit, AskUserQuestion]
+sourceDocs:
+  - libraries/cloudflare-stack-kb.md
+  - libraries/security-best-practices.md
+  - libraries/default-stack-kb.md
+use-when:
+  - novo projeto precisa configurar Cloudflare Pages
+  - usuario quer adicionar binding (D1, KV, R2, DO) a Workers existente
+  - configurar custom domain ou env vars no Pages
+  - deploy primeiro (push) ou troubleshoot CI Pages
+do-not-use-for:
+  - Vercel/Netlify/AWS (stack alternativo, usar deploy-to-vercel ou similar)
+  - apenas Workers sem Pages (ja existe wrangler init)
+metadata:
+  category: infrastructure
+---
+
+Voce esta executando como **Cloudflare Setup Helper** via skill `cloudflare-pages-setup`. Conduz setup interativo, sempre perguntando antes de gravar arquivo.
+
+## Acoes
+
+### `init` — projeto novo (Pages + Workers)
+
+1. Ler `package.json` se existir. Se nao, propor `npm create vite@latest` primeiro.
+2. AskUserQuestion sequencial:
+   - "Project name (slug Cloudflare):"
+   - "Custom domain (deixe vazio para usar `<slug>.pages.dev`):"
+   - "Backend: Pages Functions (mesmo repo, /functions/) ou Worker separado (/api/*)?"
+   - "DB: Supabase Postgres / D1 / nenhum?"
+   - "Auth: Supabase Auth / Cloudflare Access / nenhum?"
+   - "Storage: R2 / Supabase Storage / nenhum?"
+3. Gerar `wrangler.toml` apropriado (ver templates abaixo).
+4. Gerar `.env.example` + `.gitignore` (entradas para `.env`, `.dev.vars`, `node_modules`).
+5. Gerar `package.json` scripts: `dev`, `build`, `preview`, `deploy:preview`, `deploy:prod`.
+6. Mostrar `wrangler login` + `wrangler secret put <NAME>` para credentials.
+
+### `add-binding` — adicionar D1/KV/R2/DO
+
+1. Ler `wrangler.toml` existente.
+2. Pergunta: "Tipo de binding?" (D1, KV, R2, DO).
+3. Pergunta: "Nome do binding (variavel JS):" — ex `DB`, `KV`, `IMAGES`, `ROOM`.
+4. Para D1: `wrangler d1 create <name>` + adicionar bloco `[[d1_databases]]`.
+5. Para KV: `wrangler kv:namespace create <name>` + adicionar bloco `[[kv_namespaces]]`.
+6. Para R2: `wrangler r2 bucket create <name>` + bloco `[[r2_buckets]]`.
+7. Para DO: gera class skeleton em `src/durable-objects/<Name>.ts` + bloco `[[durable_objects.bindings]]` + migration.
+8. Gerar tipos TypeScript (`worker-configuration.d.ts`).
+
+### `deploy` — deploy preview ou production
+
+1. Pergunta: "Preview ou production?"
+2. Validar `wrangler.toml` parseavel.
+3. Validar build local: `npm run build`.
+4. Preview: `wrangler pages deploy dist --branch=<slug>` -> retorna URL temporaria.
+5. Prod: `wrangler pages deploy dist --branch=main` (somente se branch atual e main).
+6. Mostrar URL final + dashboard link.
+
+### `env` — gerenciar env vars / secrets
+
+1. Pergunta: "List, add, remove, ou pull?"
+2. List: `wrangler secret list` + `wrangler pages project list`.
+3. Add: `wrangler secret put <NAME>` (interativo, esconde valor digitado).
+4. Remove: `wrangler secret delete <NAME>` (confirma antes).
+5. Pull: copia env do dashboard pra `.dev.vars` local.
+
+## Templates
+
+### wrangler.toml — Pages Functions (recomendado MVP)
+
+```toml
+name = "<slug>"
+compatibility_date = "2026-05-01"
+compatibility_flags = ["nodejs_compat"]
+
+# Pages config
+pages_build_output_dir = "dist"
+
+# Bindings (descomente os que usar)
+# [[d1_databases]]
+# binding = "DB"
+# database_name = "<name>"
+# database_id = "<uuid>"
+
+# [[kv_namespaces]]
+# binding = "KV"
+# id = "<uuid>"
+
+# [[r2_buckets]]
+# binding = "R2"
+# bucket_name = "<name>"
+```
+
+### wrangler.toml — Workers separado
+
+```toml
+name = "<slug>-api"
+main = "src/worker/index.ts"
+compatibility_date = "2026-05-01"
+compatibility_flags = ["nodejs_compat"]
+
+[vars]
+PUBLIC_VAR = "value"
+
+# Secrets sao via `wrangler secret put`, nao em vars.
+
+[[d1_databases]]
+binding = "DB"
+database_name = "<name>"
+database_id = "<uuid>"
+```
+
+### Pages Functions structure
+
+```
+project/
+  functions/
+    api/
+      [[path]].ts        # catch-all com Hono opcional
+  src/
+    main.tsx              # Vite entry
+  dist/                   # build output
+  wrangler.toml
+```
+
+```ts
+// functions/api/[[path]].ts
+import { Hono } from 'hono';
+
+type Bindings = {
+  DB: D1Database;
+  // SUPABASE_URL: string;
+  // SUPABASE_SERVICE_KEY: string;
+};
+
+const app = new Hono<{ Bindings: Bindings }>();
+
+app.get('/projects', async (c) => {
+  const result = await c.env.DB.prepare('select * from projects').all();
+  return c.json(result.results);
+});
+
+export const onRequest = (ctx: any) => app.fetch(ctx.request, ctx.env, ctx);
+```
+
+## Custom domain
+
+1. `wrangler pages project list` -> confirma projeto.
+2. Dashboard -> Pages -> projeto -> Custom domains -> Add.
+3. Adicionar CNAME no DNS apontando para `<slug>.pages.dev`.
+4. Aguardar SSL (1-15min).
+
+## Checklist de seguranca pos-setup
+
+(Aplica `libraries/security-best-practices.md`)
+
+- [ ] `.env`, `.dev.vars` no `.gitignore`.
+- [ ] `service_role_key` Supabase NUNCA em `vars` do wrangler.toml — sempre `wrangler secret put`.
+- [ ] CORS configurado para origem conhecida (`Access-Control-Allow-Origin: https://<slug>.pages.dev`).
+- [ ] HTTPS forced (Cloudflare default).
+- [ ] `compatibility_date` recente (max 6 meses).
+
+## Troubleshooting comum
+
+| Erro | Causa | Fix |
+|------|-------|-----|
+| "wrangler: command not found" | nao instalado | `npm i -D wrangler` + `npx wrangler ...` |
+| "Authentication required" | nao logou | `wrangler login` (abre browser) |
+| Build falha em CI Pages | env var faltando | adicionar no dashboard Pages > Settings > Env |
+| `Workers limit exceeded` | excedeu free tier | `wrangler tail` + verificar trafego |
+| D1 query lenta | sem indice | `wrangler d1 execute <db> --command="explain query plan ..."` |
+
+## Input
+
+$ARGUMENTS

package/.gos/skills/execute-plan/SKILL.md

@@ -86,6 +86,11 @@ Comparacao:
 
 Pre-flight smoke nao substitui o visual gate por task — ele captura gaps grandes (componente faltando, KPI row ausente) que viraram tasks novas em PLAN-004/PLAN-005.
 
+**Drift map como input adicional**: se `<dirs.planos>/<PLAN-NNN-slug>/drift-map.md` existir (gerado na Fase 1.5 do `plan-blueprint`), pre-flight smoke consome cada linha:
+- Para cada divergencia listada: validar override aplicado (grep das classes/props declaradas em `## Page-level overrides`) OU task de implementacao agendada (grep `override_target:` ou `interaction_target:` nos frontmatter de `tasks/T-*.md`).
+- Item sem encaminhamento (sem override aplicado E sem task agendada) = task `T-000-XX` pre-flight com `priority: P0`, prepend na fila, renumera tasks subsequentes.
+- Drift map ausente: nao bloqueia (pipeline antigo continua funcionando).
+
 ## Loop por task
 
 Iterar tasks em ordem de `seq`. Antes de executar cada task, **classificar**: