primocode 9.8.0-beta.4 → 9.8.0-beta.6

package/lib/ide.js

@@ -0,0 +1,337 @@
+/**
+ * ide.js — a PrimoCode IDE: árvore, editor, prévia e chat, na mesma janela.
+ *
+ *   "Um app ao invés de CLI, aí fica uma IDE e uma CLI."
+ *
+ * ── POR QUE MORA DENTRO DO SERVIDOR DO /rc ───────────────────────────────
+ * A janela do /rc já resolveu o difícil: servidor em 127.0.0.1 com chave
+ * sorteada, fluxo de eventos (SSE) ao vivo e o espelho da saída do terminal.
+ * Uma IDE com servidor próprio seria uma segunda chave, uma segunda porta e um
+ * segundo fluxo — e as duas janelas mostrariam agentes que parecem diferentes
+ * sendo o mesmo. Aqui só entram as rotas que a IDE precisa a mais (árvore,
+ * ler, salvar, prévia) e o vigia da pasta, que empurra eventos pelo MESMO
+ * fluxo do /rc.
+ *
+ * ── SEGURANÇA ────────────────────────────────────────────────────────────
+ * Estas rotas leem e ESCREVEM no disco do usuário. Três travas:
+ *   · a chave do app.js vale aqui também (tudo mora em /api/);
+ *   · todo caminho é resolvido DENTRO da pasta do projeto — "../", caminho
+ *     absoluto e link simbólico que aponta para fora são recusados;
+ *   · a prévia roda num iframe sandbox SEM allow-same-origin, e o servidor
+ *     manda o mesmo sandbox no cabeçalho. O código da prévia foi escrito pelo
+ *     agente (ou pela pessoa); se ele herdasse a origem da IDE, poderia chamar
+ *     /api/enviar e dar ordens ao agente. Com origem opaca, o fetch dele sai
+ *     com `Origin: null` e o app.js recusa.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/* O que a árvore não mostra e o vigia não escuta. node_modules sozinho tem
+   dezenas de milhares de arquivos: listar travaria a janela, e vigiar faria
+   cada `npm install` virar uma avalanche de eventos. */
+const IGNORADOS = new Set(['node_modules', '.git', '.DS_Store', '.next', '.cache',
+    '__pycache__', '.venv', 'venv', '.turbo', '.parcel-cache']);
+const MAX_ITENS = 4000;
+const MAX_PROFUNDIDADE = 12;
+// 1 MB: acima disso um <textarea> engasga a cada tecla, e arquivo desse
+// tamanho num projeto de iniciante é quase sempre gerado (bundle, dado).
+const MAX_EDITOR = 1024 * 1024;
+
+// ── caminhos ─────────────────────────────────────────────────────────────
+
+/* Resolve `relativo` dentro de `raiz`, ou devolve null.
+ *
+ * `path.relative` pega o "../" e o caminho absoluto; o `realpath` pega o link
+ * simbólico, que passa pelo primeiro teste com cara de arquivo de dentro e
+ * aponta para ~/.ssh. Arquivo que ainda não existe (salvar um novo) é checado
+ * pela pasta onde vai nascer. */
+function dentro(raiz, relativo) {
+    if (typeof relativo !== 'string' || relativo.includes('\0')) return null;
+    // Absoluto é recusado de cara, e não "reinterpretado" como relativo:
+    // quem manda /etc/hosts quer o /etc/hosts, e salvar em <projeto>/etc/hosts
+    // no lugar seria uma surpresa. `C:\` e `\\servidor` também contam.
+    if (path.isAbsolute(relativo) || path.win32.isAbsolute(relativo)) return null;
+    const base = path.resolve(raiz);
+    const alvo = path.resolve(base, relativo);
+    if (!contido(base, alvo)) return null;
+    let real = base;
+    try { real = fs.realpathSync(base); } catch { return null; }
+    let existente = alvo;
+    while (!fs.existsSync(existente) && existente !== base) existente = path.dirname(existente);
+    try {
+        if (!contido(real, fs.realpathSync(existente))) return null;
+    } catch { return null; }
+    return alvo;
+}
+
+function contido(base, alvo) {
+    const rel = path.relative(base, alvo);
+    return rel === '' || (rel !== '..' && !rel.startsWith('..' + path.sep) && !path.isAbsolute(rel));
+}
+
+function relativoDe(raiz, abs) {
+    return path.relative(raiz, abs).split(path.sep).join('/');
+}
+
+function ignorado(rel) {
+    return rel.split(/[/\\]/).some((p) => IGNORADOS.has(p));
+}
+
+// ── árvore ───────────────────────────────────────────────────────────────
+
+/* Lista plana, pastas antes de arquivos, em ordem alfabética. Plana porque a
+   página monta a árvore dela do jeito que quiser, e o teste confere sem ter de
+   descer em objetos aninhados. */
+function arvore(raiz) {
+    const itens = [];
+    let cortada = false;
+    function andar(dir, prof) {
+        if (prof > MAX_PROFUNDIDADE || cortada) return;
+        let entradas;
+        try { entradas = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+        entradas = entradas.filter((e) => !IGNORADOS.has(e.name));
+        entradas.sort((a, b) => (b.isDirectory() - a.isDirectory())
+            || a.name.localeCompare(b.name, 'pt-BR', { sensitivity: 'base' }));
+        for (const e of entradas) {
+            if (itens.length >= MAX_ITENS) { cortada = true; return; }
+            const abs = path.join(dir, e.name);
+            const rel = relativoDe(raiz, abs);
+            if (e.isDirectory()) {
+                itens.push({ caminho: rel, tipo: 'pasta' });
+                andar(abs, prof + 1);
+            } else if (e.isFile()) {
+                let tamanho = 0;
+                try { tamanho = fs.statSync(abs).size; } catch {}
+                itens.push({ caminho: rel, tipo: 'arquivo', tamanho });
+            }
+        }
+    }
+    andar(raiz, 0);
+    return { itens, cortada };
+}
+
+// ── ler e salvar ─────────────────────────────────────────────────────────
+
+/* Binário é o que tem byte zero nos primeiros 8 KB — o mesmo teste do git.
+   Mostrar um PNG como texto no editor e deixar a pessoa salvar por cima
+   destruiria a imagem sem aviso. */
+function ehBinario(buf) {
+    const n = Math.min(buf.length, 8000);
+    for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
+    return false;
+}
+
+function ler(raiz, rel) {
+    const abs = dentro(raiz, rel);
+    if (!abs) return { status: 403, corpo: { ok: false, error: 'fora da pasta do projeto' } };
+    let st;
+    try { st = fs.statSync(abs); } catch { return { status: 404, corpo: { ok: false, error: 'não existe' } }; }
+    if (!st.isFile()) return { status: 400, corpo: { ok: false, error: 'não é arquivo' } };
+    const base = { ok: true, caminho: relativoDe(raiz, abs), tamanho: st.size, mtime: st.mtimeMs };
+    if (st.size > MAX_EDITOR) return { status: 200, corpo: Object.assign(base, { grande: true }) };
+    const buf = fs.readFileSync(abs);
+    if (ehBinario(buf)) return { status: 200, corpo: Object.assign(base, { binario: true }) };
+    return { status: 200, corpo: Object.assign(base, { conteudo: buf.toString('utf8') }) };
+}
+
+/* `mtimeBase` é o mtime que a página viu ao abrir o arquivo. Se o disco está
+   mais novo, alguém (quase sempre o agente) mexeu no meio — e salvar por cima
+   apagaria o trabalho dele sem ninguém perceber. A página decide: recarregar
+   ou mandar de novo com `forcar`. */
+function salvar(raiz, dados) {
+    const rel = dados && dados.caminho;
+    const conteudo = dados && dados.conteudo;
+    if (typeof conteudo !== 'string') return { status: 400, corpo: { ok: false, error: 'conteúdo faltando' } };
+    if (Buffer.byteLength(conteudo) > MAX_EDITOR) return { status: 413, corpo: { ok: false, error: 'maior que 1 MB' } };
+    const abs = dentro(raiz, rel);
+    if (!abs || abs === path.resolve(raiz)) return { status: 403, corpo: { ok: false, error: 'fora da pasta do projeto' } };
+    if (ignorado(relativoDe(raiz, abs))) return { status: 403, corpo: { ok: false, error: 'pasta protegida' } };
+    let st = null;
+    try { st = fs.statSync(abs); } catch { /* arquivo novo */ }
+    if (st && !st.isFile()) return { status: 400, corpo: { ok: false, error: 'não é arquivo' } };
+    if (st && dados.mtimeBase && !dados.forcar && st.mtimeMs > Number(dados.mtimeBase) + 1) {
+        return { status: 409, corpo: { ok: false, conflito: true, error: 'mudou no disco depois que você abriu', mtime: st.mtimeMs } };
+    }
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, conteudo);
+    return { status: 200, corpo: { ok: true, caminho: relativoDe(raiz, abs), mtime: fs.statSync(abs).mtimeMs } };
+}
+
+// ── prévia ───────────────────────────────────────────────────────────────
+
+const TIPOS = {
+    '.html': 'text/html; charset=utf-8', '.htm': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8', '.js': 'application/javascript; charset=utf-8',
+    '.mjs': 'application/javascript; charset=utf-8', '.json': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.ico': 'image/x-icon', '.txt': 'text/plain; charset=utf-8',
+    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.mp4': 'video/mp4', '.webm': 'video/webm',
+    '.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf', '.md': 'text/plain; charset=utf-8',
+};
+
+/* Onde está a página de entrada do projeto. index.html na raiz é o caso de
+   quase todo pedido ("crie um site"); os kits de Vite e afins põem em public/
+   ou src/. Sem nenhum, a prévia diz isso em vez de mostrar um 404. */
+function entradaDaPrevia(raiz) {
+    for (const c of ['index.html', 'public/index.html', 'src/index.html', 'dist/index.html']) {
+        if (fs.existsSync(path.join(raiz, c))) return c;
+    }
+    return null;
+}
+
+function servirPrevia(raiz, rel, res) {
+    const abs = dentro(raiz, decodeURIComponent(rel || '') || 'index.html');
+    const alvo = abs && fs.existsSync(abs) && fs.statSync(abs).isDirectory() ? path.join(abs, 'index.html') : abs;
+    if (!alvo || !fs.existsSync(alvo)) {
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        return res.end('não encontrado');
+    }
+    res.writeHead(200, {
+        'Content-Type': TIPOS[path.extname(alvo).toLowerCase()] || 'application/octet-stream',
+        'Cache-Control': 'no-store',
+        // O mesmo sandbox do iframe, dito pelo servidor: vale até se alguém
+        // abrir o endereço da prévia fora da IDE.
+        'Content-Security-Policy': 'sandbox allow-scripts allow-forms allow-modals allow-popups allow-pointer-lock',
+    });
+    fs.createReadStream(alvo).pipe(res);
+}
+
+// ── vigia ────────────────────────────────────────────────────────────────
+
+/* fs.watch recursivo existe no Mac e no Windows desde sempre e no Linux desde
+   o Node 20. Onde não existe, vigia só a raiz — a prévia de um index.html
+   continua acompanhando, que é o que mais importa.
+
+   Os eventos vêm em rajada (um write vira 2–3 avisos, um `npm run build` vira
+   centenas), então juntam-se por 150 ms e saem numa mensagem só. */
+function vigiar(raiz, aoMudar, espera = 150) {
+    const pendentes = new Set();
+    let timer = null;
+    const soltar = () => {
+        timer = null;
+        const lista = [...pendentes];
+        pendentes.clear();
+        if (lista.length) aoMudar(lista);
+    };
+    const anotar = (_tipo, nome) => {
+        if (!nome) return;
+        const rel = String(nome).split(path.sep).join('/');
+        if (ignorado(rel)) return;
+        pendentes.add(rel);
+        if (!timer) timer = setTimeout(soltar, espera);
+    };
+    let vigia;
+    try { vigia = fs.watch(raiz, { recursive: true }, anotar); } catch {
+        try { vigia = fs.watch(raiz, anotar); } catch { return () => {}; }
+    }
+    vigia.on('error', () => {});
+    return function parar() {
+        try { vigia.close(); } catch {}
+        if (timer) clearTimeout(timer);
+    };
+}
+
+// ── as rotas ─────────────────────────────────────────────────────────────
+
+/**
+ * Monta a IDE num servidor do app.js.
+ *
+ * @param {object} op
+ * @param {()=>string} op.pasta   a pasta do projeto AGORA (o /dir muda ela)
+ * @param {(evento:string, dados:any)=>void} op.emitir  o fluxo SSE do app.js
+ * @returns {{atender:Function, fechar:Function, conferirPasta:Function}}
+ */
+function montar(op) {
+    let pastaVigiada = null;
+    let pararVigia = () => {};
+    // O que a própria IDE acabou de salvar, para a página não pintar como
+    // "o agente mexeu" a mudança que a pessoa fez.
+    const salvosAgora = new Map();
+
+    function conferirPasta() {
+        const atual = op.pasta && op.pasta();
+        if (!atual || atual === pastaVigiada) return atual;
+        pararVigia();
+        pastaVigiada = atual;
+        if (!fs.existsSync(atual)) { pararVigia = () => {}; return atual; }
+        pararVigia = vigiar(atual, (mudados) => {
+            const agora = Date.now();
+            const deVoce = mudados.filter((m) => (salvosAgora.get(m) || 0) > agora - 1500);
+            op.emitir('arquivos', { pasta: atual, mudados, deVoce });
+        });
+        op.emitir('arquivos', { pasta: atual, mudados: [], trocou: true });
+        return atual;
+    }
+    // O /dir troca a pasta pelo terminal, sem passar por aqui: sem esta volta
+    // a IDE continuaria vigiando o projeto anterior.
+    /* E só depois que a IDE foi aberta de verdade: quem abriu só o chat do
+       /rc não precisa de ninguém vigiando o ~/primocode inteiro — no Linux
+       o fs.watch recursivo custa um aviso do sistema por pasta. */
+    let usada = false;
+    const ronda = setInterval(() => { if (usada) conferirPasta(); }, 2000);
+    if (ronda.unref) ronda.unref();
+
+    function json(res, status, corpo) {
+        res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
+        res.end(JSON.stringify(corpo));
+    }
+
+    function lerCorpo(req) {
+        return new Promise((ok) => {
+            let corpo = '';
+            let grande = false;
+            req.on('data', (c) => { corpo += c; if (corpo.length > MAX_EDITOR * 2) { grande = true; req.destroy(); } });
+            req.on('end', () => { try { ok(grande ? null : JSON.parse(corpo)); } catch { ok(null); } });
+        });
+    }
+
+    /* Devolve true se a rota era da IDE. A chave já foi conferida pelo
+       app.js antes de chegar aqui — só as rotas com /api/ passam por ela, e
+       por isso a prévia também mora debaixo de /api/. */
+    async function atender(req, res, url) {
+        const rota = url.pathname;
+        if (!rota.startsWith('/api/ide/')) return false;
+        usada = true;
+        const raiz = conferirPasta();
+        if (!raiz || !fs.existsSync(raiz)) { json(res, 404, { ok: false, error: 'sem pasta de projeto' }); return true; }
+
+        if (rota === '/api/ide/arvore') {
+            const a = arvore(raiz);
+            json(res, 200, { ok: true, pasta: raiz, nome: path.basename(raiz), itens: a.itens,
+                cortada: a.cortada, entrada: entradaDaPrevia(raiz) });
+            return true;
+        }
+        if (rota === '/api/ide/arquivo') {
+            const r = ler(raiz, url.searchParams.get('p') || '');
+            json(res, r.status, r.corpo);
+            return true;
+        }
+        if (rota === '/api/ide/salvar' && req.method === 'POST') {
+            const dados = await lerCorpo(req);
+            if (!dados) { json(res, 400, { ok: false, error: 'pedido ilegível ou maior que 1 MB' }); return true; }
+            const r = salvar(raiz, dados);
+            if (r.corpo.ok) salvosAgora.set(r.corpo.caminho, Date.now());
+            json(res, r.status, r.corpo);
+            return true;
+        }
+        /* /api/ide/previa/<chave>/<caminho>: a chave vai no CAMINHO, não na
+           query, porque a página da prévia pede style.css e script.js por
+           endereço relativo — e o relativo herda o caminho, não a query. */
+        const m = rota.match(/^\/api\/ide\/previa\/[0-9a-f]+\/?(.*)$/);
+        if (m) { servirPrevia(raiz, m[1], res); return true; }
+
+        json(res, 404, { ok: false, error: 'rota desconhecida' });
+        return true;
+    }
+
+    return {
+        atender,
+        conferirPasta,
+        fechar() { clearInterval(ronda); pararVigia(); },
+    };
+}
+
+module.exports = { montar, dentro, arvore, ler, salvar, vigiar, ehBinario, entradaDaPrevia, MAX_EDITOR };

package/lib/kits.js

@@ -1,25 +1,24 @@
 /**
- * kits.js — o modelo grátis começa de uma página pronta, e não do zero.
+ * kits.js — a IA recebe uma direção visual para se INSPIRAR, e não um molde.
  *
  *   "A IA free fez essa página, ficou boa, mas quero que ela seja mais
- *    rápida." · "Como chegar nesse nível com os modelos free? Nem terminou,
- *    demora 10 anos." (24/09/2026)
+ *    rápida." · "Mas os sites vão ficar todos iguais?" · "Eu quero que tenha
+ *    modelo pra IA só se inspirar, não pra ela mudar só texto." (24/09/2026)
  *
- * ── A CONTA ──────────────────────────────────────────────────────────────
- * Uma landing boa são ~30 KB de HTML+CSS+JS — uns 9 mil tokens de SAÍDA. No
- * plano grátis (6 mil tokens por minuto, entrada e saída juntas) isso não
- * cabe numa resposta: o servidor manda "uma tool por vez", e a página sai em
- * pedaços, com espera a cada minuto. E o modelo fraco, desenhando do zero,
- * erra justamente o que dá o nível: tipografia, espaço, animação.
+ * ── A HISTÓRIA, EM TRÊS PASSOS ───────────────────────────────────────────
+ * 1. Primeiro o kit era COPIADO para a pasta e o agente só trocava texto e
+ *    cor: rápido no plano grátis (1–2 mil tokens de saída em vez de ~9 mil),
+ *    mas todo site saía com o mesmo esqueleto.
+ * 2. Viraram cinco direções com estruturas diferentes. Ainda eram moldes.
+ * 3. Agora é INSPIRAÇÃO: nada é copiado. O agente recebe a ficha da direção
+ *    que combina com o negócio (paleta, fontes, layout, o elemento marcante,
+ *    o que evitar) e escreve a página dele. Custa mais saída que trocar
+ *    texto — o preço de cada site sair com a cara do seu negócio — e a
+ *    instrução manda escrever o CSS em partes para cada resposta caber na
+ *    cota.
  *
- * Com o kit, o design já está resolvido (a landing que o Claude fez, com o
- * conteúdo trocado por marcadores). O agente só TROCA texto e três cores com
- * edit_file: ~1–2 mil tokens de saída em vez de 9 mil. Mais rápido E melhor,
- * pela mesma razão — o trabalho difícil já foi feito uma vez, por quem faz
- * bem.
- *
- * Só entra em pasta NOVA (ou vazia): num projeto que já tem página, copiar
- * um kit por cima seria apagar o trabalho da pessoa.
+ * As páginas completas de kits/<nome>/ ficam como a prova de que cada
+ * direção funciona: foram renderizadas e conferidas, e as fichas saíram delas.
  */
 
 'use strict';
@@ -35,22 +34,153 @@ const RE_LANDING = /\b(landing|lading|p[áa]gina (de vendas|de captura|inicial|i
 // Pedido que não quer a cara do kit: nada de puxar o kit por cima disso.
 const RE_SEM_KIT = /\b(do zero|sem modelo|sem template|sem kit|react|next(\.?js)?|vue|svelte|angular|tailwind|wordpress)\b/i;
 
+/* ── INSPIRAÇÃO, NÃO MOLDE ────────────────────────────────────────────────
+ *   "Eu quero que tenha modelo pra IA só se INSPIRAR, não pra ela mudar só
+ *    texto." (24/09/2026)
+ * Os kits eram copiados para a pasta e o agente só trocava texto e cor — e
+ * todo site saía com o mesmo esqueleto. Agora nada é copiado: o agente recebe
+ * uma FICHA da direção que combina com o negócio (paleta, fontes, ideia de
+ * layout, o elemento marcante, o movimento, o que evitar) e escreve a página
+ * DELE. A ficha é curta (~1,5 mil caracteres) para caber na cota grátis. As
+ * páginas completas continuam em kits/<nome>/ como a prova de que cada
+ * direção funciona — é delas que as fichas foram tiradas. */
+function instrucaoDoKit(kit) {
+    return `INSPIRAÇÃO VISUAL (ponto de partida, NÃO é molde): direção "${kit.titulo}".\n${kit.ficha}\n\n`
+        + 'Crie a página DESTE negócio do zero (index.html, style.css e, se precisar, script.js), com o conteúdo '
+        + 'real do pedido. Use a direção acima como inspiração: pode e deve mudar a estrutura, as seções, as cores '
+        + 'e as fontes para caber no negócio — duas páginas feitas com esta ficha não devem sair iguais. Não copie '
+        + 'textos de exemplo e não invente fato que você não sabe. Antes de escrever, decida em 3 linhas o que '
+        + 'será o elemento marcante desta página. Arquivo grande: escreva o CSS em partes (a base primeiro, os '
+        + 'detalhes depois com edit_file), para cada resposta caber.';
+}
+
+/* Uma família de direções, e não uma só: "mas os sites vão ficar todos
+   iguais?" (24/09/2026). Cada uma pede uma ESTRUTURA diferente. */
 const KITS = {
     landing: {
         nome: 'landing',
-        arquivos: ['index.html', 'style.css', 'script.js'],
-        instrucao: 'A PASTA JÁ TEM UMA LANDING PRONTA (index.html, style.css, script.js), com design profissional, '
-            + 'animações e responsiva. NÃO reescreva os arquivos com write_file: é lento e piora o design. '
-            + 'ADAPTE com edit_file: (1) leia o index.html; (2) troque cada bloco marcado com <!-- TROQUE --> pelo '
-            + 'conteúdo do pedido — textos reais, específicos do negócio, sem inventar fato que você não sabe; '
-            + '(3) no topo do style.css troque só as cores --blue, --orange, --cyan (e as -deep) pelas cores que '
-            + 'combinam com o negócio; (4) troque também as FONTES (o link do Google Fonts no index.html e --sans/'
-            + '--serif no style.css) por um par que tenha a cara DESTE negócio; (5) tire o que não informa nada: '
-            + 'rótulos em caixa alta sobre os títulos, números 01/02/03 quando não é sequência; (6) apague os '
-            + 'comentários TROQUE. Pode remover uma seção que não faz sentido para o negócio (e o link dela no '
-            + 'menu). Não mexa no script.js.',
+        titulo: 'escura e tecnológica',
+        ficha: '- para: tecnologia, app, startup, barbearia, tatuagem, academia — negócio de noite ou de futuro.\n'
+            + '- paleta: fundo quase preto azulado (#0b0b12), um azul profundo (#1e3fae), um laranja de destaque '
+            + '(#f97316), um ciano de apoio (#1fb4cf).\n'
+            + '- fontes: um sans geométrico e firme para tudo (ex.: Instrument Sans, Space Grotesk, Sora) e, se '
+            + 'quiser, uma serifa só para um detalhe.\n'
+            + '- layout: abertura de tela cheia centrada, com fundo vivo (rede de pontos ou brilho que segue o '
+            + 'mouse, em canvas ou CSS); depois seções escuras largas.\n'
+            + '- marcante: o fundo animado da abertura. O resto fica sóbrio.\n'
+            + '- evite: fade em toda seção, números 01/02/03, rótulo em caixa alta sobre todo título.',
+    },
+    editorial: {
+        nome: 'editorial',
+        titulo: 'editorial clara',
+        ficha: '- para: advocacia, consultoria, contabilidade, fotografia, curso, mentoria, agência.\n'
+            + '- paleta: papel quase branco (#fcfcfb), tinta quase preta (#141414), UM azul forte (#1432c8) usado '
+            + 'pouco, e um azul bem claro (#e7ebfb) para uma faixa.\n'
+            + '- fontes: um título condensado e pesado (ex.: Archivo condensada, Oswald, Anton) + uma serifa de '
+            + 'leitura para o texto (ex.: Newsreader, Source Serif, Literata).\n'
+            + '- layout: tudo alinhado à ESQUERDA numa grade assimétrica (coluna estreita de rótulo + coluna larga '
+            + 'de conteúdo); serviços em LINHAS separadas por filete, não em cards; um depoimento grande em itálico.\n'
+            + '- marcante: o título da abertura, enorme e apertado, ocupando metade da tela.\n'
+            + '- movimento: quase nenhum. Formulário só com a linha de baixo nos campos.',
+    },
+    acolhedor: {
+        nome: 'acolhedor',
+        titulo: 'acolhedora de bairro',
+        ficha: '- para: padaria, confeitaria, salão, clínica, dentista, pet, escola, creche — o negócio da esquina.\n'
+            + '- paleta: fundo creme quente (#fff9f2), um verde acolhedor (#2f7a5f), amarelo sol (#ffc247) e um '
+            + 'coral (#f28b74). Troque pelo que combinar com o ramo.\n'
+            + '- fontes: um título redondo e simpático (ex.: Fredoka, Baloo 2, Nunito ExtraBold) + um texto '
+            + 'arredondado e legível (ex.: Nunito, Quicksand).\n'
+            + '- layout: texto à esquerda e, à direita, uma ILUSTRAÇÃO feita só com CSS que lembra o negócio '
+            + '(lojinha com toldo listrado, bolo, patinha, dente) — nada de imagem de fora; quadro de preços com '
+            + 'pontilhado ligando nome e preço; falas de cliente em balões; botão de WhatsApp em destaque.\n'
+            + '- marcante: um selo "Aberto agora, até as 18h" calculado pelo horário real (script.js).\n'
+            + '- tudo arredondado (raios grandes), nada de fundo escuro.',
+    },
+    vitrine: {
+        nome: 'vitrine',
+        titulo: 'vitrine colorida',
+        ficha: '- para: comida, pizzaria, hamburgueria, açaí, evento, festa, loja, lançamento de produto.\n'
+            + '- paleta: cores chapadas e vivas em BLOCOS: amarelo (#ffd23f), rosa (#ff4f8b), azul elétrico '
+            + '(#2d5bff), preto (#141414). Contorno grosso preto entre os blocos.\n'
+            + '- fontes: um grotesco bem pesado e expressivo para títulos GIGANTES (ex.: Bricolage Grotesque, '
+            + 'Archivo Black, Rubik) — pode ser a mesma família no texto.\n'
+            + '- layout: cartaz de rua. Abertura em um bloco de cor com título que quase estoura a tela; faixa '
+            + 'com quando/onde/preço; MOSAICO de produtos com tamanhos diferentes (um grande, vários pequenos), '
+            + 'cada um com etiqueta de preço inclinada; chamada final enorme ("Bora?").\n'
+            + '- marcante: um selo serrilhado girado ("Só nesta semana") e, se houver data, a contagem em '
+            + 'palavras ("Faltam 12 dias").\n'
+            + '- evite: cards iguais com sombra suave e degradê.',
+    },
+    premium: {
+        nome: 'premium',
+        titulo: 'minimalista premium',
+        ficha: '- para: arquitetura, joalheria, imobiliária, hotel, spa, estética, vinho — serviço de alto padrão.\n'
+            + '- paleta: fundo pedra clara (#f4f4f1), um verde muito escuro (#1f3a34), um dourado envelhecido '
+            + '(#b8955a) só em fios e detalhes, e um cinza quente (#dcd9d2).\n'
+            + '- fontes: uma serifa de alto contraste, fina e grande, para títulos (ex.: Bodoni Moda, Playfair '
+            + 'Display, Cormorant) + um sans discreto e pequeno para o texto (ex.: Manrope, Inter).\n'
+            + '- layout: tudo CENTRADO, com MUITO espaço vazio; poucas seções e curtas; três frentes de trabalho '
+            + 'lado a lado só com um fio fino em cima; depoimento curto; contato com hora marcada.\n'
+            + '- marcante: UM elemento só na abertura (ex.: um arco de cor escura com um fio dourado e uma luz), '
+            + 'que se mexe uma vez ao abrir. Nada mais se mexe.\n'
+            + '- botões finos, só contorno. Antes de terminar, tire um enfeite.',
     },
 };
+for (const kit of Object.values(KITS)) kit.instrucao = instrucaoDoKit(kit);
+
+/* Tira acento e caixa: "Clínica", "clinica" e "CLÍNICA" viram a mesma
+   coisa, e o \b do JavaScript volta a funcionar (ele não entende "í"). */
+function normalizar(texto) {
+    return String(texto || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+}
+
+/* Pedido explícito de estilo vence o ramo do negócio: quem diz "estilo
+   editorial" para a padaria quer a editorial. */
+const ESTILO_PEDIDO = [
+    ['editorial', /\b(editorial|estilo (de )?revista|cara de revista|jornal[ií]stic[oa])\b/],
+    ['acolhedor', /\b(acolhedor[a]?|aconchegante|fofo|fofa|amigavel|caseir[oa])\b/],
+    ['vitrine', /\b(vitrine|colorid[oa]|vibrante|chamativ[oa]|divertid[oa]|bold|cartaz)\b/],
+    ['premium', /\b(premium|minimalista|minimal|sofisticad[oa]|elegante|luxuos[oa]|de luxo|alto padrao)\b/],
+    ['landing', /\b(escur[oa]|dark|futurista|tecnologic[oa]|neon)\b/],
+];
+
+/* O ramo do negócio → a direção que combina. Ganha a palavra que aparece
+   PRIMEIRO no pedido ("app da padaria" é sobre o app). */
+const RAMO = [
+    ['acolhedor', /\b(padaria|confeitaria|doceria|salao|cabeleireir[oa]|manicure|clinica|dentista|odonto\w*|consultorio|pet ?shop|pet|veterinari[oa]|escola|creche|bercario|psicolog[oa]|fisioterap\w*|nutricionista|lavanderia|floricultura|mercadinho|costureira|artesanato)\b/],
+    ['vitrine', /\b(evento|festa|show|festival|comida|lanchonete|lanche|hamburgueria|hamburguer|pizzaria|pizza|sorveteria|acai|food ?truck|delivery|loja|produto|lancamento|promocao|brecho|bar|cervejaria|churrasco|doces?)\b/],
+    ['editorial', /\b(advocacia|advogad[oa]|consultoria|contabilidade|contador[a]?|jornal|revista|blog|podcast|fotograf[oa]|fotografia|escritor[a]?|livro|palestrante|mentoria|curso|agencia)\b/],
+    ['premium', /\b(arquitetura|arquitet[oa]|joalheria|joias?|imobiliaria|imoveis|corretor[a]?|interiores|hotel|pousada|spa|vinho|vinicola|estetica|relojoaria|alfaiataria|perfumaria)\b/],
+    ['landing', /\b(tech|startup|app|aplicativo|software|saas|ia|inteligencia artificial|plataforma|games?|barbearia|tattoo|tatuagem|estudio|academia|crossfit)\b/],
+];
+
+/* Sem pista nenhuma, a escolha RODA pelo texto do pedido: o mesmo pedido cai
+   sempre no mesmo kit (dá para reproduzir), mas dois pedidos diferentes não
+   caem sempre no mesmo — que era exatamente a reclamação. */
+const ORDEM_RODIZIO = ['editorial', 'acolhedor', 'vitrine', 'premium', 'landing'];
+function hashDoPedido(texto) {
+    let h = 5381;
+    for (const ch of normalizar(texto).trim()) h = ((h * 33) ^ ch.codePointAt(0)) >>> 0;
+    return h;
+}
+
+function primeiraPista(t, tabela) {
+    let melhor = null;
+    for (const [nome, re] of tabela) {
+        const m = re.exec(t);
+        if (m && (!melhor || m.index < melhor.pos)) melhor = { nome, pos: m.index };
+    }
+    return melhor && melhor.nome;
+}
+
+/** Qual direção visual combina com o pedido (sem as regras de quando usar kit). */
+function direcao(pedido) {
+    const t = normalizar(pedido);
+    return primeiraPista(t, ESTILO_PEDIDO)
+        || primeiraPista(t, RAMO)
+        || ORDEM_RODIZIO[hashDoPedido(pedido) % ORDEM_RODIZIO.length];
+}
 
 /* O kit é para quem NÃO consegue desenhar bem sozinho no tempo da cota. O
    motor forte (Claude Code, Codex, a chave do Claude ou do ChatGPT) desenha do
@@ -62,34 +192,15 @@ function motorForte(provedorAtual) {
     return Boolean(provedorAtual && (provedorAtual.cli || FORTES.has(provedorAtual.id)));
 }
 
-/** Qual kit este pedido quer, ou null. */
+/** Qual kit este pedido quer, ou null. A direção sai do negócio (ou do estilo pedido). */
 function escolher(pedido, { provedor = null } = {}) {
-    if (motorForte(provedor)) return null;
+    // A ficha é inspiração, não molde: vale para qualquer motor. O forte usa
+    // de partida junto da skill design-de-verdade; o grátis ganha uma direção
+    // em vez de inventar do zero. (`provedor` fica para quem quiser distinguir.)
+    void provedor;
     const t = String(pedido || '');
     if (!RE_LANDING.test(t) || RE_SEM_KIT.test(t)) return null;
-    return KITS.landing;
-}
-
-/** A pasta está livre para receber o kit? (não existe, ou só tem memory.md) */
-function pastaLivre(dir) {
-    try {
-        const tem = fs.readdirSync(dir).filter((n) => !n.startsWith('.') && n !== 'memory.md');
-        return tem.length === 0;
-    } catch { return true; }
-}
-
-/** Copia o kit para `dir`. Devolve os arquivos copiados, ou [] se não copiou. */
-function aplicar(kit, dir) {
-    if (!kit || !pastaLivre(dir)) return [];
-    fs.mkdirSync(dir, { recursive: true });
-    const feitos = [];
-    for (const nome of kit.arquivos) {
-        const destino = path.join(dir, nome);
-        if (fs.existsSync(destino)) continue;
-        fs.copyFileSync(path.join(PASTA_KITS, kit.nome, nome), destino);
-        feitos.push(nome);
-    }
-    return feitos;
+    return KITS[direcao(t)];
 }
 
-module.exports = { KITS, PASTA_KITS, escolher, pastaLivre, aplicar, motorForte };
+module.exports = { KITS, PASTA_KITS, escolher, direcao, normalizar, motorForte, instrucaoDoKit };

package/lib/skills.js

@@ -345,9 +345,14 @@ const semAcento = (v) => String(v || '').toLowerCase()
 function pontuar(skill, texto) {
     const t = semAcento(texto);
     let pontos = 0;
+    // "página, pagina" no gatilho é UMA palavra escrita de dois jeitos: sem
+    // acento as duas são iguais e contavam dois pontos, e a skill que listava
+    // as duas grafias ganhava das outras só por isso.
+    const vistas = new Set();
     for (const palavra of skill.quando) {
         const p = semAcento(palavra).trim();
-        if (!p) continue;
+        if (!p || vistas.has(p)) continue;
+        vistas.add(p);
         const escapado = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         // A borda e escrita a mao em vez de `\b`: o gatilho pode comecar ou
         // terminar em simbolo ("e-mail"), e ali o `\b` nao vale.