primocode 9.8.0-beta.2 → 9.8.0-beta.4

package/lib/perigo.js

@@ -0,0 +1,256 @@
+/**
+ * perigo.js — o que não tem volta pede licença antes.
+ *
+ * Até aqui o PrimoCode rodava qualquer `run_shell` e escrevia qualquer arquivo
+ * sem perguntar. Para quase tudo isso é certo: quem não programa não sabe
+ * responder "autoriza `npm install`?", e uma pergunta que ninguém sabe
+ * responder vira um "sim" automático. O problema é o resto — o `rm -rf ~`, o
+ * `git push --force`, o `curl … | sh`. Esses não se desfazem.
+ *
+ * Por isso a régua é estreita DE PROPÓSITO: perigoso é o que apaga, reescreve
+ * história ou sai da pasta do projeto. `rm -rf node_modules` dentro do projeto
+ * NÃO é perigoso — se fosse, o Primo perguntaria dez vezes por dia, e na
+ * décima primeira a pessoa diria sim sem ler. Falso positivo aqui é tão ruim
+ * quanto falso negativo: ele treina a pessoa a não ler a pergunta.
+ *
+ * Os três modos (/permissoes):
+ *   auto      — o padrão. Roda tudo, mas SEMPRE pergunta antes do perigoso.
+ *   perguntar — pergunta antes de todo comando e de toda escrita de arquivo.
+ *   livre     — nunca pergunta. Nem o perigoso.
+ */
+
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+const MODOS = ['auto', 'perguntar', 'livre'];
+const COMANDOS = new Set(['run_shell', 'run_in_new_terminal']);
+const ESCRITAS = new Set(['write_file', 'edit_file', 'multi_edit']);
+
+function normalizarModo(m) {
+    const s = String(m || '').trim().toLowerCase();
+    const apelido = { ask: 'perguntar', suggest: 'perguntar', full: 'livre', 'full-auto': 'livre', yolo: 'livre' };
+    const n = apelido[s] || s;
+    return MODOS.includes(n) ? n : 'auto';
+}
+
+/* Quebra o comando em trechos (separados por ; && || | e quebra de linha) e
+   cada trecho em palavras — respeitando aspas. Sem respeitar aspas,
+   `git commit -m "tira o rm -rf /"` viraria um trecho `rm -rf /` e o Primo
+   pararia para perguntar sobre uma mensagem de commit. */
+function trechos(cmd) {
+    const saida = [];
+    let palavras = [], atual = '', aspa = null, temPalavra = false;
+    const fechaPalavra = () => { if (temPalavra) palavras.push(atual); atual = ''; temPalavra = false; };
+    const fechaTrecho = (sep) => { fechaPalavra(); if (palavras.length) saida.push({ palavras, sep }); palavras = []; };
+    const s = String(cmd || '');
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (aspa) {
+            if (ch === aspa) aspa = null;
+            else if (ch === '\\' && aspa === '"' && i + 1 < s.length) atual += s[++i];
+            else atual += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") { aspa = ch; temPalavra = true; continue; }
+        if (ch === '\\' && i + 1 < s.length) { atual += s[++i]; temPalavra = true; continue; }
+        if (ch === ';' || ch === '\n') { fechaTrecho(';'); continue; }
+        if (ch === '&' && s[i + 1] === '&') { fechaTrecho(';'); i++; continue; }
+        if (ch === '|' && s[i + 1] === '|') { fechaTrecho(';'); i++; continue; }
+        if (ch === '|') { fechaTrecho('|'); continue; }
+        if (ch === '&') { fechaTrecho(';'); continue; }
+        if (/\s/.test(ch)) { fechaPalavra(); continue; }
+        atual += ch; temPalavra = true;
+    }
+    fechaTrecho(';');
+    return saida;
+}
+
+const TEMPORARIAS = [...new Set(['/tmp', '/private/tmp', os.tmpdir()])];
+
+function dentro(pai, filho) {
+    const r = path.relative(pai, filho);
+    return !!r && !r.startsWith('..') && !path.isAbsolute(r);
+}
+
+function expandir(alvo) {
+    const home = os.homedir();
+    return String(alvo).replace(/^~(?=\/|$)/, home).replace(/^\$\{?HOME\}?(?=\/|$)/, home);
+}
+
+/** O alvo cai FORA do projeto (ou é o projeto inteiro, ou um curinga que o esvazia)? */
+function alvoRuim(alvo, cwd, projeto, { recursivo, raizOk = false }) {
+    const a = String(alvo);
+    if (/^\.?\/?\*$|^\.\*$/.test(a)) return recursivo ? 'apaga tudo o que tem na pasta' : null;
+    const e = expandir(a);
+    // Variável que não é o HOME: não dá para saber aonde aponta, e "não sei"
+    // num rm é motivo de perguntar.
+    if (/\$/.test(e)) return 'apaga um caminho que depende de variável';
+    const alvoAbs = path.resolve(cwd, e.replace(/\/\*$/, ''));
+    const rel = path.relative(projeto, alvoAbs);
+    if (e === '/' || alvoAbs === path.parse(alvoAbs).root) return 'apaga a partir da raiz do computador';
+    if (alvoAbs === os.homedir()) return 'apaga a sua pasta pessoal inteira';
+    if (rel === '') return raizOk ? null : 'apaga a pasta do projeto inteira';
+    // A pasta temporária é descartável por definição: limpar lá não é perigo.
+    // (Mas nunca o que mora dentro da sua pasta pessoal.)
+    if (!dentro(os.homedir(), alvoAbs) && TEMPORARIAS.some((t) => dentro(t, alvoAbs))) return null;
+    if (rel.startsWith('..') || path.isAbsolute(rel)) return `apaga algo fora da pasta do projeto (${a})`;
+    return null;
+}
+
+// Palavras que vêm ANTES do comando de verdade e não mudam o que ele faz.
+const PREFIXOS = new Set(['env', 'nohup', 'time', 'command', 'exec', 'nice', 'xargs']);
+
+function analisarTrecho(palavras, estado) {
+    let p = palavras.slice();
+    // `VAR=x cmd`, `env -i cmd`, `xargs -0 rm`: pula até o comando.
+    while (p.length && (PREFIXOS.has(p[0]) || /^[A-Za-z_]\w*=/.test(p[0]) || (estado.pulandoFlags && /^-/.test(p[0])))) {
+        estado.pulandoFlags = PREFIXOS.has(p[0]) && p[0] !== 'command';
+        p.shift();
+    }
+    estado.pulandoFlags = false;
+    if (!p.length) return null;
+    const cmd = path.basename(p[0]);
+    const args = p.slice(1);
+    const flags = args.filter((x) => /^-/.test(x));
+    const alvos = args.filter((x) => !/^-/.test(x));
+    const tem = (re) => flags.some((f) => re.test(f));
+
+    if (cmd === 'sudo' || cmd === 'doas') return 'usa sudo: mexe como administrador no computador inteiro';
+    if (cmd === 'cd') { estado.cwd = path.resolve(estado.cwd, expandir(alvos[0] || os.homedir())); return null; }
+    if ((cmd === 'sh' || cmd === 'bash' || cmd === 'zsh') && args[0] === '-c' && args[1]) {
+        return analisarComando(args[1], estado.cwd, estado.projeto);
+    }
+    if (cmd === 'rm' || cmd === 'rmdir' || cmd === 'trash') {
+        const recursivo = cmd === 'rmdir' || tem(/^-[a-zA-Z]*[rR]|^--recursive$/);
+        for (const a of alvos) {
+            const r = alvoRuim(a, estado.cwd, estado.projeto, { recursivo });
+            if (r) return r;
+        }
+        return null;
+    }
+    if (cmd === 'find' && args.includes('-delete')) {
+        for (const a of alvos.slice(0, 1)) {
+            const r = alvoRuim(a, estado.cwd, estado.projeto, { recursivo: true, raizOk: true });
+            if (r) return r.replace(/^apaga/, 'apaga com find');
+        }
+        return null;
+    }
+    if (cmd === 'git') {
+        const sub = alvos[0];
+        if (sub === 'push' && (tem(/^--force$|^-[a-zA-Z]*f/) || alvos.some((a) => /^\+/.test(a)))) {
+            return 'git push --force: reescreve o histórico no GitHub, e o que estava lá some';
+        }
+        if (sub === 'reset' && flags.includes('--hard')) return 'git reset --hard: joga fora o que não foi salvo em commit';
+        if (sub === 'clean' && tem(/^-[a-zA-Z]*f/) && !tem(/^-[a-zA-Z]*n|^--dry-run$/)) {
+            return 'git clean: apaga arquivos que o git não guardou';
+        }
+        return null;
+    }
+    if (cmd === 'dd') return 'dd: escreve direto no disco';
+    if (/^mkfs(\.|$)/.test(cmd) || cmd === 'newfs' || cmd === 'fdisk') return 'formata um disco';
+    if (cmd === 'diskutil' && /^(erase|zero|secureErase|partitionDisk|reformat)/i.test(alvos[0] || '')) return 'diskutil: apaga um disco';
+    if ((cmd === 'chmod' || cmd === 'chown') && tem(/^-[a-zA-Z]*R/)) {
+        for (const a of alvos) {
+            const e = path.resolve(estado.cwd, expandir(a));
+            if (e === '/' || e === os.homedir()) return `${cmd} -R em ${a}: muda a permissão de tudo`;
+        }
+        return null;
+    }
+    if (cmd === 'kill' && args.includes('-1')) return 'kill -1: encerra todos os seus programas';
+    if (['shutdown', 'reboot', 'halt', 'poweroff'].includes(cmd)) return 'desliga ou reinicia o computador';
+    if (['npm', 'pnpm', 'yarn'].includes(cmd) && alvos[0] === 'publish' && !flags.includes('--dry-run')) return `${cmd} publish: publica o pacote para o mundo inteiro`;
+    return null;
+}
+
+function analisarComando(comando, cwd, projeto) {
+    const s = String(comando || '');
+    // Baixar e rodar na hora: o que roda é o que o site mandar naquele segundo.
+    if (/\b(curl|wget)\b[^;&]*\|\s*(sudo\s+)?(env\s+)?(ba|z|da|k)?sh\b/.test(s)) {
+        return 'baixa um script da internet e roda sem ler';
+    }
+    const estado = { cwd, projeto, pulandoFlags: false };
+    for (const t of trechos(s)) {
+        const r = analisarTrecho(t.palavras, estado);
+        if (r) return r;
+    }
+    return null;
+}
+
+/**
+ * Esta ação é perigosa?
+ * @returns {{perigoso: boolean, motivo: string}}
+ */
+function classificar(nome, args, { projectDir } = {}) {
+    const a = args || {};
+    const projeto = path.resolve(projectDir || process.cwd());
+    let motivo = null;
+    if (COMANDOS.has(nome)) {
+        const cwd = a.cwd ? path.resolve(projeto, expandir(a.cwd)) : projeto;
+        motivo = analisarComando(a.command, cwd, projeto);
+    } else if (ESCRITAS.has(nome) && a.path) {
+        const alvo = path.resolve(projeto, expandir(a.path));
+        const rel = path.relative(projeto, alvo);
+        if (rel.startsWith('..') || path.isAbsolute(rel) || /^[a-zA-Z]:[\\/]/.test(String(a.path))) {
+            motivo = `mexe num arquivo fora da pasta do projeto (${a.path})`;
+        }
+    }
+    return { perigoso: !!motivo, motivo: motivo || '' };
+}
+
+function novo() { return { liberados: new Set(), negados: new Set() }; }
+
+/* Uma pergunta por vez. Subagentes rodam em paralelo (Promise.all) e dois
+   pedidos ao mesmo tempo no mesmo terminal se atropelariam. */
+let fila = Promise.resolve();
+function emFila(fn) { const p = fila.then(fn, fn); fila = p.catch(() => {}); return p; }
+
+/**
+ * O portão. Devolve {ok:true} ou {ok:false, error, motivo}.
+ *
+ * `perguntar(frase, {tipo, motivo, primeira})` → 'agora' | 'sessao' | 'nao',
+ * o mesmo contrato do portão do desktop (lib/permissao.js).
+ */
+async function portao(estado, { modo, nome, args, projectDir, subagent = false, perguntar = null }) {
+    const m = normalizarModo(modo);
+    if (m === 'livre') return { ok: true };
+    const { perigoso, motivo: motivoPerigo } = classificar(nome, args, { projectDir });
+    const tipo = perigoso ? 'perigo' : (m === 'perguntar' && COMANDOS.has(nome)) ? 'comando'
+        : (m === 'perguntar' && ESCRITAS.has(nome)) ? 'arquivo' : null;
+    if (!tipo) return { ok: true };
+
+    const motivo = perigoso ? motivoPerigo
+        : tipo === 'comando' ? `rodar: ${String((args || {}).command || '').slice(0, 80)}`
+            : `escrever ${String((args || {}).path || 'um arquivo')}`;
+    const recusa = (texto) => ({ ok: false, motivo, error: texto });
+
+    // Escrever fora da pasta o tools.js já recusa sozinho: perguntar seria
+    // pedir um "sim" que não serve para nada.
+    if (perigoso && ESCRITAS.has(nome)) {
+        return recusa(`Recusado: ${motivo}. O PrimoCode só escreve dentro da pasta do projeto — use /dir se a pessoa quiser trabalhar em outra pasta.`);
+    }
+    if (subagent) {
+        return recusa(`Recusado: ${motivo}. Subagente não tem como pedir autorização — `
+            + 'deixe esse passo para o agente principal e diga no seu resumo o que falta fazer.');
+    }
+    const chave = `${nome}:${JSON.stringify(args || {})}`;
+    const negado = `A pessoa não autorizou: ${motivo}. Siga por outro caminho ou pergunte.`;
+    if (estado.negados.has(chave)) return recusa(negado);
+    // "A sessão inteira" libera o TIPO de pergunta: no perigoso, aquele motivo
+    // (um push --force autorizado não autoriza um rm -rf ~); no modo
+    // perguntar, os comandos ou as escritas comuns.
+    const liberacao = perigoso ? `perigo:${motivo}` : tipo;
+    if (estado.liberados.has(liberacao)) return { ok: true };
+    if (typeof perguntar !== 'function') {
+        return recusa(`Recusado: ${motivo}. Isso precisa de autorização e não há ninguém para autorizar neste modo.`);
+    }
+
+    const resposta = await emFila(() => perguntar(motivo, { tipo, motivo, primeira: false }));
+    if (resposta === 'sessao') { estado.liberados.add(liberacao); return { ok: true }; }
+    if (resposta === 'agora') return { ok: true };
+    estado.negados.add(chave);
+    return recusa(negado);
+}
+
+module.exports = { classificar, portao, novo, normalizarModo, trechos, MODOS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.2",
+  "version": "9.8.0-beta.4",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/kits.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js"
   },
   "engines": {
     "node": ">=18.17.0"
@@ -30,8 +30,10 @@
     "app/",
     "studio/",
     "skills/",
+    "kits/",
     "voz/",
     "README.md",
+    "comandos/",
     "!**/__pycache__",
     "!**/*.pyc",
     "!**/*.pyo",

package/skills/design-de-verdade/LICENSE.txt

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

package/skills/design-de-verdade/SKILL.md

@@ -0,0 +1,40 @@
+---
+nome: Design de verdade
+descricao: cada site com identidade própria, e não a cara de "feito por IA"
+quando: landing, landing page, site, página, pagina, design, interface, tela, layout, visual, bonito, bonita, identidade, marca
+autor: adaptado de "frontend-design" (Anthropic, anthropics/skills, Apache-2.0 — ver LICENSE.txt); resumido e traduzido pelo PrimoCode
+---
+Trabalhe como o diretor de arte de um estúdio conhecido por dar a cada cliente uma identidade que
+ninguém confunde. O cliente já recusou propostas com cara de modelo pronto.
+
+**Comece pelo assunto.** O ramo, os materiais e o vocabulário do negócio são de onde vem a escolha
+visual. Um brinquedo para meninas de 8 anos e um painel de analista financeiro não se parecem em nada.
+Use o conteúdo real do pedido em tudo, e não texto genérico.
+
+**Planeje antes de escrever código**, em poucas linhas:
+- cor: 4 a 6 cores com nome e hex;
+- tipo: 1 ou 2 fontes escolhidas para ESTE negócio (não as de sempre), com papéis claros;
+- layout: a ideia em uma frase, e se o conteúdo alinha à esquerda ou ao centro;
+- o único elemento memorável da página.
+Depois releia o plano. O que você faria igual para qualquer página parecida, troque, e diga o que trocou.
+
+**As marcas de página gerada por IA.** Evite estas, a não ser que o pedido peça:
+- fundo creme com serifa e destaque terracota; ou fundo quase preto com um único destaque neon;
+- conteúdo picado em cards idênticos, com o mesmo arredondado e a mesma sombra em tudo;
+- rótulo em CAIXA ALTA espaçada acima de todo título, e textos "A · B · C" com ponto no meio;
+- uma única palavra do título em itálico ou em outra cor;
+- números 01 / 02 / 03 quando o conteúdo não é uma sequência de verdade;
+- a mesma entrada com fade subindo em toda seção, e hover em todo card;
+- uma seta "→" em todo botão.
+
+**Contenção.** Gaste a ousadia num lugar só: um elemento marcante, o resto calmo. Antes de entregar,
+tire um enfeite. Movimento só num momento orquestrado (a abertura, por exemplo) ou em resposta a uma
+ação da pessoa.
+
+**Piso de qualidade, sem anunciar:** funciona no celular, foco de teclado visível, respeita "reduzir
+movimento", contraste acessível, linhas de texto com menos de 80 caracteres.
+
+**Texto é design.** Escreva do ponto de vista de quem usa, com palavras simples. O botão diz o que
+acontece ("Agendar horário", e não "Enviar"). Específico vence esperto. Voz ativa, sem enrolação.
+
+**Confira com os olhos:** abra a página, tire um print e critique o que viu antes de dizer que terminou.