ganbatte-os 0.2.36 → 0.2.38

package/.gos/skills/gos-compress/scripts/compress.py

@@ -0,0 +1,346 @@
+"""
+compress.py — Script principal da skill sandeco-token-reduce.
+
+Comprime texto com LLMLingua-2 e opcionalmente envia ao Claude.
+Auto-detecta GPU.
+
+Requer inicializacao previa com setup.py.
+
+Modos:
+    So comprimir:       python compress.py --file texto.txt --rate 0.4
+    Comprimir + salvar: python compress.py --file texto.txt --rate 0.4 --output comprimido.txt
+    Comprimir + Claude: python compress.py --file texto.txt --rate 0.4 --ask "Resuma este texto"
+    Saida JSON:         python compress.py --file texto.txt --rate 0.4 --json
+"""
+
+import argparse
+import json as json_mod
+import re
+import sys
+from pathlib import Path
+
+
+SKILL_DIR = Path(__file__).parent.parent
+VENV_DIR = SKILL_DIR / ".venv"
+
+
+# -- Verificacao de ambiente ---------------------------------------------------
+
+def check_environment():
+    """Verifica se o venv existe e se estamos rodando dentro dele."""
+    venv_python = VENV_DIR / "Scripts" / "python.exe"
+    if not venv_python.exists():
+        venv_python = VENV_DIR / "bin" / "python"
+
+    if not VENV_DIR.exists() or not venv_python.exists():
+        print("ERRO: A skill ainda nao foi inicializada.", file=sys.stderr)
+        print(f"Execute primeiro: python \"{SKILL_DIR / 'scripts' / 'setup.py'}\"",
+              file=sys.stderr)
+        sys.exit(1)
+
+    if sys.prefix == sys.base_prefix:
+        print(f"ERRO: Execute este script com o Python do venv:", file=sys.stderr)
+        print(f"  \"{venv_python}\" \"{__file__}\" ...", file=sys.stderr)
+        sys.exit(1)
+
+
+# -- Compressor ----------------------------------------------------------------
+
+def detect_device() -> str:
+    try:
+        import torch
+        if torch.cuda.is_available():
+            return "cuda"
+    except ImportError:
+        pass
+    return "cpu"
+
+
+MODEL_NAME = "microsoft/llmlingua-2-xlm-roberta-large-meetingbank"
+CHUNK_MAX_TOKENS = 400
+COMPRESS_KWARGS = dict(
+    force_tokens=[
+        # Estruturais
+        "\n", ".", ",", "?", "!", ":", ";",
+        # Negacoes PT
+        "não", "sem", "nenhum", "nunca", "nem", "nenhuma",
+        # Prioridade / obrigatoriedade
+        "Must", "must", "Obrigatória", "obrigatória",
+        # Operacionais
+        "npm", "run", "dev",
+        # Resiliencia / fallback
+        "retry", "fallback", "timeout", "WAL", "graciosamente",
+        # Metricas
+        "baseline", "target", "Baseline", "Target",
+        # Delimitadores de codigo inline
+        "`",
+    ],
+    force_reserve_digit=True,
+    drop_consecutive=True,
+)
+
+
+def load_compressor():
+    from llmlingua import PromptCompressor
+
+    device = detect_device()
+    print(f"Carregando LLMLingua-2 (device={device})...", file=sys.stderr)
+    return PromptCompressor(
+        model_name=MODEL_NAME,
+        use_llmlingua2=True,
+        device_map=device,
+    )
+
+
+def load_tokenizer():
+    from transformers import AutoTokenizer
+    return AutoTokenizer.from_pretrained(MODEL_NAME)
+
+
+# -- Pre-processamento markdown ------------------------------------------------
+
+def tables_to_keyvalue(text: str) -> str:
+    """Converte tabelas markdown para formato key: value que sobrevive a compressao."""
+    lines = text.split('\n')
+    result = []
+    i = 0
+    while i < len(lines):
+        if lines[i].strip().startswith('|') and '|' in lines[i][1:]:
+            table_lines = []
+            while i < len(lines) and lines[i].strip().startswith('|'):
+                table_lines.append(lines[i])
+                i += 1
+            if len(table_lines) < 2:
+                result.extend(table_lines)
+                continue
+            headers = [h.strip() for h in table_lines[0].split('|')[1:-1]]
+            for tl in table_lines[1:]:
+                if re.match(r'^\s*\|[-:\s|]+\|\s*$', tl):
+                    continue
+                values = [v.strip() for v in tl.split('|')[1:-1]]
+                for h, v in zip(headers, values):
+                    if v:
+                        result.append(f"{h}: {v}")
+                result.append('')
+        else:
+            result.append(lines[i])
+            i += 1
+    return '\n'.join(result)
+
+
+def normalize_identifiers(text: str) -> str:
+    """Gruda prefixos de IDs aos digitos para que force_reserve_digit proteja o conjunto.
+    Ex: G-01 -> G01, RF-01 -> RF01, EC-04 -> EC04"""
+    return re.sub(r'\b(G|RF|RNF|NG|EC)-(\d+)', r'\1\2', text)
+
+
+def strip_markdown(text: str) -> str:
+    """Remove decoracao markdown mantendo o conteudo textual."""
+    text = re.sub(r'^---+\s*$', '', text, flags=re.MULTILINE)       # separadores
+    text = re.sub(r'\*\*(.+?)\*\*', r'\1', text)                    # **bold** -> texto
+    text = re.sub(r'^#{1,6}\s+', '', text, flags=re.MULTILINE)      # ## headers -> texto
+    text = re.sub(r'- \[[ x]\]\s*', '', text)                       # checkboxes
+    text = re.sub(r'^```\w*\s*$', '', text, flags=re.MULTILINE)     # code fences (triple)
+    text = re.sub(r'\n{3,}', '\n\n', text)                          # colapsar linhas vazias
+    return text.strip()
+
+
+# -- Chunking ------------------------------------------------------------------
+
+def split_into_chunks(text: str, tokenizer, max_tokens: int = CHUNK_MAX_TOKENS) -> list[str]:
+    """Divide texto em chunks de ate max_tokens, cortando em limites de linha."""
+    lines = text.split('\n')
+    chunks = []
+    current_lines = []
+    current_tokens = 0
+
+    for line in lines:
+        line_tokens = len(tokenizer.encode(line, add_special_tokens=False))
+        if current_tokens + line_tokens > max_tokens and current_lines:
+            chunks.append('\n'.join(current_lines))
+            current_lines = []
+            current_tokens = 0
+        current_lines.append(line)
+        current_tokens += line_tokens
+
+    if current_lines:
+        chunks.append('\n'.join(current_lines))
+
+    return chunks
+
+
+# -- Compressao ----------------------------------------------------------------
+
+def compress(text: str, rate: float) -> dict:
+    text = tables_to_keyvalue(text)
+    text = normalize_identifiers(text)
+    text = strip_markdown(text)
+    compressor = load_compressor()
+    tokenizer = load_tokenizer()
+
+    chunks = split_into_chunks(text, tokenizer)
+
+    if len(chunks) == 1:
+        result = compressor.compress_prompt(text, rate=rate, **COMPRESS_KWARGS)
+        return {
+            "compressed_prompt": result["compressed_prompt"],
+            "origin_tokens": result["origin_tokens"],
+            "compressed_tokens": result["compressed_tokens"],
+            "ratio": round(float(str(result["ratio"]).rstrip("x")), 2),
+            "saving": result["origin_tokens"] - result["compressed_tokens"],
+            "rate_requested": rate,
+        }
+
+    print(f"Texto dividido em {len(chunks)} chunks (max {CHUNK_MAX_TOKENS} tokens cada).",
+          file=sys.stderr)
+
+    compressed_parts = []
+    total_origin = 0
+    total_compressed = 0
+
+    for i, chunk in enumerate(chunks, 1):
+        r = compressor.compress_prompt(chunk, rate=rate, **COMPRESS_KWARGS)
+        compressed_parts.append(r["compressed_prompt"])
+        total_origin += r["origin_tokens"]
+        total_compressed += r["compressed_tokens"]
+        print(f"  Chunk {i}/{len(chunks)}: {r['origin_tokens']} -> {r['compressed_tokens']} tokens",
+              file=sys.stderr)
+
+    ratio = round(total_origin / total_compressed, 2) if total_compressed > 0 else 0.0
+
+    return {
+        "compressed_prompt": "\n".join(compressed_parts),
+        "origin_tokens": total_origin,
+        "compressed_tokens": total_compressed,
+        "ratio": ratio,
+        "saving": total_origin - total_compressed,
+        "rate_requested": rate,
+    }
+
+
+# -- Claude --------------------------------------------------------------------
+
+def ask_claude(compressed_text: str, question: str, model: str, max_tokens: int) -> dict:
+    import anthropic
+
+    client = anthropic.Anthropic()
+    prompt = f"""Contexto (comprimido via LLMLingua-2 — tokens irrelevantes foram removidos,
+mas o significado foi preservado):
+
+{compressed_text}
+
+Pergunta: {question}"""
+
+    response = client.messages.create(
+        model=model,
+        max_tokens=max_tokens,
+        messages=[{"role": "user", "content": prompt}],
+    )
+
+    answer = ""
+    for block in response.content:
+        if block.type == "text":
+            answer += block.text
+
+    return {
+        "answer": answer,
+        "model": model,
+        "input_tokens": response.usage.input_tokens,
+        "output_tokens": response.usage.output_tokens,
+    }
+
+
+# -- CLI -----------------------------------------------------------------------
+
+def parse_args():
+    p = argparse.ArgumentParser(
+        description="Comprime tokens com LLMLingua-2 (Microsoft)"
+    )
+    # Entrada
+    group = p.add_mutually_exclusive_group(required=True)
+    group.add_argument("--text", help="Texto a comprimir")
+    group.add_argument("--file", help="Caminho para arquivo de texto")
+
+    # Compressao
+    p.add_argument("--rate", type=float, default=0.4,
+                   help="Fracao de tokens a manter: 0.5=leve, 0.4=padrao, 0.2=agressivo")
+
+    # Saida
+    p.add_argument("--output", "-o", help="Salva texto comprimido neste arquivo")
+    p.add_argument("--json", action="store_true",
+                   help="Saida em JSON (util para integracao programatica)")
+
+    # Claude (opcional)
+    p.add_argument("--ask", help="Pergunta a enviar ao Claude com o contexto comprimido")
+    p.add_argument("--model", default="claude-sonnet-4-6",
+                   help="Modelo Claude (padrao: claude-sonnet-4-6)")
+    p.add_argument("--max-tokens", type=int, default=4096,
+                   help="Max tokens na resposta do Claude (padrao: 4096)")
+
+    return p.parse_args()
+
+
+def main():
+    check_environment()
+
+    args = parse_args()
+
+    # Carregar texto
+    if args.file:
+        path = Path(args.file)
+        if not path.exists():
+            print(f"ERRO: arquivo nao encontrado: {path}", file=sys.stderr)
+            sys.exit(1)
+        text = path.read_text(encoding="utf-8")
+    else:
+        text = args.text
+
+    if not text.strip():
+        print("ERRO: texto vazio.", file=sys.stderr)
+        sys.exit(1)
+
+    # Comprimir
+    result = compress(text, args.rate)
+
+    # Salvar se pedido
+    if args.output:
+        out = Path(args.output)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(result["compressed_prompt"], encoding="utf-8")
+        print(f"Salvo em: {out.resolve()}", file=sys.stderr)
+
+    # Perguntar ao Claude se pedido
+    claude_result = None
+    if args.ask:
+        claude_result = ask_claude(
+            result["compressed_prompt"], args.ask, args.model, args.max_tokens
+        )
+
+    # Saida
+    if args.json:
+        output = {
+            "compression": result,
+        }
+        if claude_result:
+            output["claude"] = claude_result
+        print(json_mod.dumps(output, ensure_ascii=False, indent=2))
+    else:
+        print(f"\nTokens originais:    {result['origin_tokens']}")
+        print(f"Tokens comprimidos:  {result['compressed_tokens']}")
+        print(f"Taxa de compressao:  {result['ratio']}x")
+        print(f"Tokens economizados: {result['saving']}")
+
+        if not args.output:
+            print(f"\n--- Texto comprimido ---")
+            print(result["compressed_prompt"])
+            print("------------------------")
+
+        if claude_result:
+            print(f"\n--- Resposta do Claude ({args.model}) ---")
+            print(claude_result["answer"])
+            print(f"\nTokens Claude — input: {claude_result['input_tokens']}, "
+                  f"output: {claude_result['output_tokens']}")
+
+
+if __name__ == "__main__":
+    main()

package/.gos/skills/gos-compress/scripts/setup.py

@@ -0,0 +1,91 @@
+"""
+setup.py — Inicializacao da skill sandeco-token-reduce.
+
+Cria o .venv, instala dependencias e baixa o modelo LLMLingua-2.
+Deve ser executado uma unica vez antes de usar a skill.
+
+Uso:
+    python setup.py
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+SKILL_DIR = Path(__file__).parent.parent
+VENV_DIR = SKILL_DIR / ".venv"
+PACKAGES = ["llmlingua", "anthropic"]
+
+
+def venv_python():
+    """Retorna o caminho do Python dentro do .venv (Windows e Unix)."""
+    win = VENV_DIR / "Scripts" / "python.exe"
+    unix = VENV_DIR / "bin" / "python"
+    return win if win.exists() else unix
+
+
+def run(cmd, **kwargs):
+    print(f"  $ {' '.join(str(c) for c in cmd)}")
+    result = subprocess.run(cmd, **kwargs)
+    if result.returncode != 0:
+        print(f"\nERRO: comando falhou com codigo {result.returncode}")
+        sys.exit(result.returncode)
+
+
+def main():
+    print("=" * 60)
+    print("  sandeco-token-reduce — Inicializacao")
+    print("=" * 60)
+    print(f"\n  Skill dir: {SKILL_DIR}")
+    print(f"  Venv dir:  {VENV_DIR}\n")
+
+    # 1. Criar o venv
+    if not VENV_DIR.exists():
+        print("[1/4] Criando ambiente virtual (.venv)...")
+        run([sys.executable, "-m", "venv", str(VENV_DIR)])
+        print("  OK\n")
+    else:
+        print("[1/4] .venv ja existe, pulando criacao.\n")
+
+    python = venv_python()
+    if not python.exists():
+        print(f"ERRO: Python do venv nao encontrado em {python}")
+        sys.exit(1)
+
+    # 2. Atualizar pip
+    print("[2/4] Atualizando pip...")
+    run([str(python), "-m", "pip", "install", "--upgrade", "pip", "-q"])
+    print("  OK\n")
+
+    # 3. Instalar pacotes
+    print(f"[3/4] Instalando dependencias: {', '.join(PACKAGES)}")
+    print("  (isso pode levar alguns minutos na primeira vez)")
+    run([str(python), "-m", "pip", "install"] + PACKAGES + ["-q"])
+    print("  OK\n")
+
+    # 4. Baixar o modelo LLMLingua-2 (faz uma compressao minima para forcar o download)
+    print("[4/4] Baixando modelo LLMLingua-2 (~1 GB na primeira vez)...")
+    print("  (o modelo fica em cache em ~/.cache/huggingface/)")
+    download_script = (
+        "from llmlingua import PromptCompressor; "
+        "c = PromptCompressor("
+        "model_name='microsoft/llmlingua-2-xlm-roberta-large-meetingbank', "
+        "use_llmlingua2=True, device_map='cpu'); "
+        "r = c.compress_prompt('Hello world test.', rate=0.5); "
+        "print('  Modelo carregado com sucesso!')"
+    )
+    run([str(python), "-c", download_script])
+    print()
+
+    # Resumo
+    print("=" * 60)
+    print("  Inicializacao concluida!")
+    print("=" * 60)
+    print(f"\n  Python do venv: {python}")
+    print(f"\n  A skill esta pronta para uso.")
+    print(f"  Peca ao Claude para comprimir um texto!")
+    print()
+
+
+if __name__ == "__main__":
+    main()

package/.gos/skills/idea-intake/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: idea-intake
+description: >
+  Entrevista guiada estilo Mom Test + SPIN para extrair a ideia de um usuario nao-tecnico
+  e transformar em intake.md estruturado. Pergunta-a-pergunta adaptativo, em PT-BR, ate ter
+  problema, persona, jobs-to-be-done, telas-chave e metrica de sucesso. Output unico:
+  docs/intake/INTAKE-NNN-<slug>/intake.md.
+argument-hint: "<frase curta da ideia ou 'continuar' para retomar sessao>"
+allowedTools: [Read, Glob, Grep, Bash, Write, Edit, AskUserQuestion]
+sourceDocs:
+  - libraries/intake-questions-mom-test.md
+  - templates/intakeTemplate.md
+use-when:
+  - usuario nao-tecnico chega com uma ideia ainda crua ("queria um app que...")
+  - antes de qualquer plan-blueprint ou design quando nao existe PRD
+  - quando a saida final esperada e um prototipo descartavel/MVP
+do-not-use-for:
+  - quando o usuario ja tem PRD (use prd-from-intake apontando para o doc)
+  - tarefas tecnicas concretas (use plan-blueprint direto)
+metadata:
+  category: discovery
+---
+
+Voce esta executando como **Entrevistador de Discovery** via skill `idea-intake`. Conduz uma entrevista pergunta-a-pergunta com um usuario nao-tecnico, em PT-BR, ate produzir um intake.md completo que servira de input para `prd-from-intake`.
+
+## Contrato
+
+1. NUNCA pergunte mais de 1 coisa por vez. Uma pergunta. Espera resposta. Proxima pergunta.
+2. Linguagem coloquial, sem jargao tecnico. Se precisar perguntar algo tecnico, traduzir em analogia ("imagina que sua ideia precisa de um caderno onde a informacao fica salva mesmo se voce fechar o app — pra voce isso e importante?").
+3. Maximo de 15 perguntas. Se atingir o teto, fecha com o que tem.
+4. Persistir progresso em `.gos-local/intake-session.json` apos cada pergunta respondida (resume com `*idea-intake continuar`).
+5. Output final unico: `docs/intake/INTAKE-NNN-<slug>/intake.md`. NUNCA escrever em outros lugares.
+
+## Estrutura da entrevista (5 blocos, 2-3 perguntas cada)
+
+### Bloco 1 — Problema (Mom Test: presente, nao futuro)
+
+- "Me conta uma situacao real, nas ultimas semanas, em que voce ou alguem que voce conhece passou por esse problema." (forca historia concreta)
+- "Como voce resolveu na hora? Mesmo que mal resolvido."
+- "O que mais te incomodou nessa hora?"
+
+Anti-padrao: nao perguntar "voce pagaria por uma solucao?" ou "seria legal se...?". Mom Test rejeita hipoteticos.
+
+### Bloco 2 — Persona
+
+- "Quem mais alem de voce viveria isso? Tenta descrever uma pessoa especifica (nao um cargo)."
+- "Essa pessoa esta em qual contexto quando o problema bate? (no celular, na rua, no escritorio, com filho do lado, etc.)"
+
+### Bloco 3 — Jobs-to-be-done
+
+- "Se essa solucao existisse magicamente amanha, qual seria a primeira coisa que voce faria com ela?"
+- "E o que voce QUERIA que ela NAO fizesse? (limites)"
+
+### Bloco 4 — Telas-chave (extracao visual sem jargao)
+
+Adaptativo. Pergunta varia conforme tipo de produto (app/site/dashboard/automacao). Padrao:
+
+- "Imagina que voce abriu o produto agora. O que voce ESPERA ver na primeira tela?"
+- "Tem alguma tela que voce sabe que vai precisar mas nao sabe explicar como? Tenta desenhar com palavras."
+- "Tem algum produto que ja faz parecido e te inspira? (link, nome, ou descricao)"
+
+### Bloco 5 — Sucesso e escopo descartavel
+
+CRITICO: explicitar que a maioria dos MVPs serao descartaveis (uso unico). Pergunta:
+
+- "Esse produto e pra usar UMA vez (validar uma ideia, mostrar pra alguem, testar conceito) ou voce quer manter rodando por meses?"
+- "Como voce vai saber, depois de usar, que valeu a pena? (metrica em linguagem humana — 'minha mae conseguiu agendar sozinha', 'consegui fechar 1 venda')"
+
+## Pre-flight (gate)
+
+1. Se `$ARGUMENTS` == "continuar": ler `.gos-local/intake-session.json`. Se nao existir, abortar com "Nenhuma sessao em curso. Comece com `*idea-intake <sua ideia>`."
+2. Se `$ARGUMENTS` e frase curta: criar nova sessao, slug = kebab-case dos primeiros 4 substantivos. Persistir em `.gos-local/intake-session.json`.
+3. Verificar se existe `libraries/intake-questions-mom-test.md` no projeto (em projetos que consomem o G-OS via `.gos/`). Se sim, ler para enriquecer perguntas com banco contextualizado.
+
+## Persistencia
+
+`.gos-local/intake-session.json`:
+
+```json
+{
+  "session_id": "intake-2026-05-09T14-22-03",
+  "slug": "agendamento-mae",
+  "ideia_seed": "queria um app que minha mae use pra...",
+  "block": 3,
+  "qa": [
+    { "block": 1, "q": "...", "a": "..." }
+  ],
+  "started_at": "<iso>",
+  "updated_at": "<iso>"
+}
+```
+
+## Saida final (intake.md)
+
+```markdown
+---
+intake_id: INTAKE-NNN-<slug>
+status: pronto-para-prd
+descartavel: true|false
+created_at: <iso>
+---
+
+# <Titulo curto da ideia>
+
+## Problema (em uma frase)
+<sintese feita pelo agente, validada com o usuario antes de fechar>
+
+## Historias reais coletadas
+- <bullet 1>
+- <bullet 2>
+
+## Persona
+<descricao em prosa, contexto incluido>
+
+## Jobs-to-be-done
+- Quando <situacao>, eu quero <acao>, para que <resultado>.
+
+## Limites (o que NAO fazer)
+- <bullet>
+
+## Telas-chave (visao bruta)
+1. <tela 1 — descricao em palavras leigas>
+2. <tela 2>
+
+## Inspiracoes
+- <link ou nome>
+
+## Escopo
+- Descartavel: <sim|nao>
+- Vida util esperada: <uma vez|semanas|meses|continuo>
+
+## Metrica de sucesso (linguagem humana)
+<frase do usuario>
+
+## Proximo passo
+- Rodar `*prd-from-intake INTAKE-NNN-<slug>` para gerar PRD lean.
+```
+
+## Regras criticas
+
+- **Falsificar antes de fechar**: ao final do bloco 5, mostrar resumo em 5 bullets e perguntar "isso reflete o que voce quer?". Se usuario corrigir algo, voltar 1 bloco.
+- **Sem chumbar tecnologia**: nao mencionar React, Cloudflare, Supabase, banco, API. Decisoes tecnicas sao da `adr-tech-decisions`, NAO daqui.
+- **Descartavel-first**: se usuario indicar uso unico, marcar `descartavel: true` no frontmatter — `prd-from-intake` e `adr-tech-decisions` usam isso para dimensionar arquitetura (sem auth complexa, sem CI/CD elaborado, etc.).
+
+## Input
+
+$ARGUMENTS

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

@@ -27,9 +27,16 @@ Você está executando como **Tech Lead Frontend / Arquiteto Sênior** via skill
 
 1. Escrever `plan.md` + `context.md`.
 2. **Invocar `plan-to-tasks`** apontando para o `plan.md` recém-criado — gera os `T-NN*.md` em `tasks/`.
-3. Atualizar `progress.txt` (skill `progress-tracker set`).
-4. **Rodar `node <repo>/.gos/scripts/integrations/check-plan.js <plan-dir>`** — gate determinístico.
-5. Exit 0 → devolver "plano criado" com resumo. Exit != 0 → regerar tasks 1x e re-rodar; se persistir, ABORTAR e devolver a saída do check-plan ao usuário.
+3. **Invocar `ui-guardrails <plan-dir>`** — bloqueia se faltar estado/responsivo/a11y/tokens em qualquer task de UI. Skip permitido se `descartavel: true` no frontmatter (passa a warning).
+4. Atualizar `progress.txt` (skill `progress-tracker set`).
+5. **Rodar `node <repo>/.gos/scripts/integrations/check-plan.js <plan-dir>`** — gate determinístico.
+6. (Opcional, default ligado) Comprimir secoes prosa do plan.md via `gos-caveman full` — preserva codigo/tabelas/frontmatter, comprime ## Contexto e ## Notas.
+7. Exit 0 → devolver "plano criado" com resumo. Exit != 0 → regerar tasks 1x e re-rodar; se persistir, ABORTAR e devolver a saída do check-plan ao usuário.
+
+### Flags de token-control
+- `--no-compress` — desliga gos-caveman (default ligado).
+- `--no-guardrails` — pula ui-guardrails (apenas para descartaveis).
+- `--compress-context` — comprime docs/stack.md + ADRs antes de injetar (via gos-compress, requer setup).
 
 Plano sem tasks (tasks/ vazio ou ausente) é falha — não é "plano parcial". Skill que devolve "plano criado" sem ter rodado o check-plan está em estado inválido.
 
@@ -128,6 +135,33 @@ Política Figma vs Storybook (ver Fase 2):
 
 > Story define API/anatomia do componente; refinamentos cosméticos da página são aceitos via override registrado em `## Page-level overrides`. **Em conflito visual, Figma da página vence**.
 
+### 1.5 Drift map antecipado
+
+Executa ANTES de Fase 3 emitir tasks. Materializa divergências Figma↔Storybook por componente para que cada uma vire override (a/b/c) ou task explícita logo no plano, evitando o padrão PLAN-005 (39 deltas descobertos durante execução).
+
+Para cada componente em "Componentes mapeados":
+
+a) **Screenshot do Figma**: via Figma MCP `get_image` pelo node-id do componente OU export do frame. Salva em `<dirs.planos>/<PLAN-NNN-slug>/drift/<Componente>.figma.png`. Reusa imagem existente entre re-runs (cache).
+b) **Screenshot da story canônica**: usa Storybook estático (`<dirs.storybook>/storybook-static`) ou local rodando. Salva em `<dirs.planos>/<PLAN-NNN-slug>/drift/<Componente>.story.png`. Se nem estático nem local: pula esse componente com warning.
+c) **Diff curto**: cria `<dirs.planos>/<PLAN-NNN-slug>/drift/<Componente>.diff.md` com 3 colunas (Anatomia diff, Token diff, Estados ausentes). Inspeção visual + grep no CSS extraído via Figma MCP. Sem pixel-diff.
+d) **Drift map cumulativo**: `<dirs.planos>/<PLAN-NNN-slug>/drift-map.md` lista canônica de TODAS divergências detectadas. Cada linha alimenta `## Page-level overrides` (decisão a/b/c) OU vira task na Fase 3 com `override_target:` ou `interaction_target:` apontando.
+
+Bloqueio:
+- Figma MCP indisponível E Storybook indisponível → `drift-map.md` = `"drift detection skipped: missing tooling (Figma MCP + Storybook)"`. Warning único, NÃO bloqueia.
+- Figma MCP disponível mas Storybook ausente → roda apenas captura Figma; diff fica vazio mas registra `figma_url` por componente para usar em execute-plan.
+- Ambos disponíveis → drift map é input obrigatório da Fase 3 (cada divergência DEVE ter encaminhamento override OU task).
+
+### 1.6 Cleanup de starter legado
+
+Detecção: ler `.gos-local/plan-paths.json` campo opcional `legacy_starter_dirs: []` (ex.: `["src/figma-make/", "tmp/stitch-export/"]`). Vazio OU ausente → pula esta sub-fase. Preenchido:
+
+a) Para cada componente em "Componentes mapeados", `grep` o nome do componente nos `legacy_starter_dirs`. Match → registrar em `<dirs.planos>/<PLAN-NNN-slug>/legacy-cleanup.md` com path do arquivo legado encontrado.
+b) Para a tela alvo (`<dirs.app>/<rota-da-tela>`), `grep` por imports oriundos de `legacy_starter_dirs`. Match → registrar arquivo + linha em `legacy-cleanup.md`.
+c) **Fase 3 emite tasks `T-NN-cleanup-legacy-<slug>`** (uma por arquivo legado) com `cleanup_target: <path>` no frontmatter. Ordem: cleanup roda DEPOIS da implementação real do componente DS (depende do `interaction_target` correspondente estar `concluido`), ANTES de fechar o plano.
+d) Sem o campo `legacy_starter_dirs`: comportamento atual preservado 100%. Projetos sem starter legado não pagam custo desta sub-fase.
+
+Por que: declara "código Make/Stitch não fica" como contrato do pipeline, não como lembrança humana task-a-task.
+
 ## Fase 2 — Aderência à Stack
 
 **Modo padrão (sem `--allow-arch-change`)**: SOMENTE referenciar a stack já registrada em `stack.md`. Para cada dado/ação da tela, listar:
@@ -140,6 +174,17 @@ Saída desta fase é uma seção **"Aderência à Stack"** no plano — não red
 
 **Modo `--allow-arch-change`**: pode propor alteração. Gerar ADR em `dirs.adr` (template `templates/adr-tmpl.yaml`) ANTES de prosseguir. Plano referencia o ADR e marca `arch_change: true` no frontmatter.
 
+### 2.4 Schema/contrato gate (executa antes de Fase 3)
+
+Quando a tela exibe ou consome dados, validar contrato backend ANTES de emitir tasks frontend dependentes — evita o padrão PLAN-012/013 (schema descoberto incompleto durante execução).
+
+a) Para cada campo exibido na tela (extraído de "Componentes mapeados" + "Interações & Estados"):
+   - **Postman**: `grep` do endpoint esperado em `<dirs.postman>`. Endpoint ausente → entrada em `## Backend pendings` tipo `endpoint-missing`, gap-key formato `endpoint-<rota>-missing`.
+   - **Prisma/SQL**: ler arquivos declarados em `plan-paths.json` campo `backend_schema_files: []` (ex.: `["packages/api/prisma/schema.prisma"]`). Campo ausente → entrada `field-missing: <table>.<field>`, gap-key formato `field-<table>-<field>-missing`.
+b) Cada entrada gerada cria task ClickUp via `mcp__clickup__clickup_create_task` (assignee `112010775` ou override `ASSIGNEE`, list `clickup.backend_list_id`) ANTES da Fase 3 emitir tasks frontend dependentes. ClickUp ID grava em `## Backend pendings`.
+c) Tasks frontend que dependem do campo recebem frontmatter `depends_on_backend: [<gap-key>]` automaticamente — `*execute-plan` já trata como `bloqueada-backend`.
+d) Nenhum dos arquivos declarados existe (sem Postman E sem `backend_schema_files`) → warning único, NÃO bloqueia. Plano segue sem schema gate.
+
 ### 2.5 Backend gaps → ClickUp automático
 
 Postman é o **contrato backend**. Para cada dado/ação da tela: