@zaip-ai/cli 2.2.0 → 3.0.0

package/templates/.agents/skills/zaip-skill-github-deploy/scripts/validate-release-notes.mjs

@@ -0,0 +1,184 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+
+const categoryHeadings = new Map([
+  ["feat", "Novidades"],
+  ["added", "Novidades"],
+  ["fix", "Correções"],
+  ["perf", "Desempenho"],
+  ["refactor", "Alterações internas"],
+  ["build", "Alterações internas"],
+  ["ci", "Alterações internas"],
+  ["test", "Alterações internas"],
+  ["chore", "Alterações internas"],
+  ["changed", "Alterações internas"],
+  ["security", "Segurança"],
+  ["breaking", "Alterações incompatíveis e migrações"],
+  ["migration", "Alterações incompatíveis e migrações"],
+  ["removed", "Alterações incompatíveis e migrações"],
+  ["deprecated", "Alterações incompatíveis e migrações"],
+  ["docs", "Documentação"],
+]);
+const releaseHeadings = new Set([
+  "Novidades",
+  "Correções",
+  "Desempenho",
+  "Alterações internas",
+  "Segurança",
+  "Alterações incompatíveis e migrações",
+  "Documentação",
+]);
+const { values } = parseArgs({
+  options: {
+    repository: { type: "string" },
+    from: { type: "string" },
+    initial: { type: "boolean", default: false },
+    to: { type: "string" },
+    "notes-file": { type: "string" },
+    "inventory-file": { type: "string" },
+  },
+  strict: true,
+});
+for (const option of ["repository", "to", "notes-file", "inventory-file"]) {
+  if (!values[option]) throw new Error("--" + option + " is required");
+}
+if (values.initial === Boolean(values.from))
+  throw new Error("use exactly one of --from <previous-tag> or --initial");
+if (!/^[a-f0-9]{40}$/i.test(values.to))
+  throw new Error("--to must be an explicit immutable 40-character candidate SHA");
+
+const repository = resolve(values.repository);
+const [notesBytes, inventoryBytes, candidate] = await Promise.all([
+  readFile(resolve(repository, values["notes-file"])),
+  readFile(resolve(repository, values["inventory-file"])),
+  gitText(repository, ["rev-parse", "--verify", values.to + "^{commit}"]),
+]);
+if (candidate.trim().toLowerCase() !== values.to.toLowerCase())
+  throw new Error("--to must resolve to the supplied immutable candidate SHA");
+if (!values.initial)
+  await gitText(repository, ["merge-base", "--is-ancestor", values.from, values.to]);
+const changed = values.initial
+  ? await gitBytes(repository, ["ls-tree", "-rz", "--name-only", values.to])
+  : await gitBytes(repository, [
+      "diff",
+      "--name-only",
+      "-z",
+      "--no-renames",
+      "--diff-filter=ACMRTD",
+      values.from + ".." + values.to,
+    ]);
+const notes = new TextDecoder("utf-8", { fatal: true }).decode(notesBytes);
+const inventory = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(inventoryBytes));
+validate(notes, inventory, values, nulPaths(changed));
+process.stdout.write(
+  JSON.stringify({
+    status: "passed",
+    files: inventory.files.length,
+    topics: inventory.topics.length,
+    semantic_review: "required",
+  }) + "\n",
+);
+
+function validate(notes, inventory, values, actualFiles) {
+  const visible = stripFencedCode(notes);
+  if (visible.trim().length === 0) throw new Error("release notes body is empty");
+  const visibleBullets = bulletLines(visible);
+  if (/^\s*(?:full changelog|compare changes)\s*:/im.test(visible) && visibleBullets.length === 0)
+    throw new Error("release notes cannot be compare-only");
+  if (/--generate-notes|\bTBD\b|\bN\/A\b/i.test(visible))
+    throw new Error("release notes contain a generated-notes flag or placeholder");
+  if (!Array.isArray(inventory.files) || !Array.isArray(inventory.topics))
+    throw new Error("inventory must contain files and topics arrays");
+  if (inventory.from !== (values.initial ? null : values.from) || inventory.to !== values.to)
+    throw new Error("inventory range must exactly match the immutable candidate selection");
+  const inventoryFiles = unique(inventory.files);
+  if (!inventoryFiles.every(isPath) || !sameSet(actualFiles, inventoryFiles))
+    throw new Error("inventory files must exactly cover the changed Git range");
+  if (inventory.topics.length === 0)
+    throw new Error("inventory must describe at least one release topic");
+  const mappedFiles = [];
+  const mappedBullets = new Set();
+  for (const topic of inventory.topics) {
+    if (!categoryHeadings.has(topic?.category)) throw new Error("topic category is invalid");
+    if (typeof topic?.bullet !== "string" || !visibleBullets.includes(topic.bullet))
+      throw new Error("every inventory topic bullet must appear outside fenced examples");
+    if (mappedBullets.has(topic.bullet)) throw new Error("inventory topic bullets must be unique");
+    mappedBullets.add(topic.bullet);
+    if (!Array.isArray(topic.files) || topic.files.length === 0 || !topic.files.every(isPath))
+      throw new Error("every topic must map to at least one changed file");
+    mappedFiles.push(...topic.files);
+  }
+  if (!sameSet(inventoryFiles, unique(mappedFiles)))
+    throw new Error("release topics must exactly cover every inventoried file");
+  const headings = [...visible.matchAll(/^## (.+)$/gm)].map((match) => ({
+    name: match[1],
+    index: match.index,
+  }));
+  if (headings[0]?.name !== "Resumo")
+    throw new Error("release notes must open with a Resumo heading");
+  const firstCategory = headings.find((heading) => releaseHeadings.has(heading.name));
+  if (
+    visible.slice(headings[0].index + "## Resumo".length, firstCategory?.index).trim().length === 0
+  )
+    throw new Error("Resumo must contain plain-language release context before categories");
+  if (!headings.some((heading) => releaseHeadings.has(heading.name)))
+    throw new Error("release notes need at least one categorized heading");
+  const categoryBullets = new Map();
+  for (let index = 0; index < headings.length; index += 1) {
+    const heading = headings[index];
+    if (!releaseHeadings.has(heading.name)) continue;
+    const section = visible.slice(
+      heading.index + heading.name.length + 3,
+      headings[index + 1]?.index,
+    );
+    const bullets = bulletLines(section);
+    if (bullets.length === 0)
+      throw new Error("every recognized category section must contain a bullet");
+    categoryBullets.set(heading.name, bullets);
+  }
+  const expected = new Set(inventory.topics.map((topic) => topic.bullet));
+  const actual = new Set([...categoryBullets.values()].flat());
+  if (!sameSet([...expected].sort(), [...actual].sort()))
+    throw new Error("category bullets must exactly match inventory topics");
+  for (const topic of inventory.topics) {
+    if (!categoryBullets.get(categoryHeadings.get(topic.category))?.includes(topic.bullet)) {
+      throw new Error("topic bullet must appear under its mapped category heading");
+    }
+  }
+}
+function stripFencedCode(source) {
+  return source.replace(/^ {0,3}(\`\`\`|~~~)[\s\S]*?^ {0,3}\1\s*$/gm, "");
+}
+function bulletLines(source) {
+  return (source.match(/^\s*-\s+.+$/gm) ?? []).map((line) => line.trim());
+}
+function nulPaths(bytes) {
+  return unique(
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes).split("\0").filter(Boolean),
+  );
+}
+function unique(values) {
+  return [...new Set(values)].sort();
+}
+function sameSet(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function isPath(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function gitText(cwd, args) {
+  return git(cwd, args, "utf8");
+}
+function gitBytes(cwd, args) {
+  return git(cwd, args, "buffer");
+}
+function git(cwd, args, encoding) {
+  return new Promise((resolveResult, reject) => {
+    execFile("git", args, { cwd, encoding }, (error, stdout, stderr) => {
+      if (error) reject(new Error("git " + args.join(" ") + " failed: " + String(stderr).trim()));
+      else resolveResult(stdout);
+    });
+  });
+}

package/templates/.agents/skills/zaip-skill-github-deploy/scripts/validate-release-notes.test.mjs

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { execFile as run } from "node:child_process";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import test from "node:test";
+
+const script = resolve(import.meta.dirname, "validate-release-notes.mjs");
+
+test("accepts categorized reviewed notes that fully cover the exact range", async () => {
+  const root = await repository();
+  await writeFile(
+    resolve(root, "notes.md"),
+    "## Resumo\n\n- A release improves publication quality.\n\n## Novidades\n\n- **Feature:** Adds a useful capability for release reviewers.\n",
+    "utf8",
+  );
+  await writeFile(
+    resolve(root, "inventory.json"),
+    JSON.stringify({
+      from: "v1.0",
+      to: (await command("git", ["rev-parse", "HEAD"], root)).trim(),
+      files: ["feature.md"],
+      topics: [
+        {
+          category: "feat",
+          bullet: "- **Feature:** Adds a useful capability for release reviewers.",
+          files: ["feature.md"],
+        },
+      ],
+    }),
+    "utf8",
+  );
+  await expectValidation(root, 0);
+});
+
+test("rejects a compare-only body and incomplete range inventory", async () => {
+  const root = await repository();
+  await writeFile(
+    resolve(root, "notes.md"),
+    "Full Changelog: [v1.0...v1.1](https://example.test)\n",
+    "utf8",
+  );
+  await writeFile(
+    resolve(root, "inventory.json"),
+    JSON.stringify({
+      from: "v1.0",
+      to: (await command("git", ["rev-parse", "HEAD"], root)).trim(),
+      files: [],
+      topics: [],
+    }),
+    "utf8",
+  );
+  const result = await expectValidation(root, 1);
+  assert.match(result.stderr, /release notes cannot be compare-only/);
+});
+
+async function repository() {
+  const root = await mkdtemp(resolve(tmpdir(), "zaip-release-notes-"));
+  await command("git", ["init", "--quiet"], root);
+  await command("git", ["config", "user.email", "test@example.com"], root);
+  await command("git", ["config", "user.name", "Test"], root);
+  await writeFile(resolve(root, "feature.md"), "before\n", "utf8");
+  await command("git", ["add", "feature.md"], root);
+  await command("git", ["commit", "--quiet", "-m", "initial"], root);
+  await command("git", ["tag", "v1.0"], root);
+  await writeFile(resolve(root, "feature.md"), "after\n", "utf8");
+  await command("git", ["commit", "--quiet", "-am", "feature"], root);
+  return root;
+}
+
+function expectValidation(cwd, expectedCode) {
+  return new Promise((resolveResult, reject) => {
+    command("git", ["rev-parse", "HEAD"], cwd)
+      .then((sha) =>
+        run(
+          process.execPath,
+          [
+            script,
+            "--repository",
+            cwd,
+            "--from",
+            "v1.0",
+            "--to",
+            sha.trim(),
+            "--notes-file",
+            "notes.md",
+            "--inventory-file",
+            "inventory.json",
+          ],
+          { cwd },
+          (error, stdout, stderr) => {
+            const code = error?.code ?? 0;
+            if (code !== expectedCode)
+              reject(new Error(`expected ${expectedCode}, got ${code}: ${stderr}`));
+            else resolveResult({ stdout, stderr });
+          },
+        ),
+      )
+      .catch(reject);
+  });
+}
+
+function command(file, args, cwd) {
+  return new Promise((resolveResult, reject) => {
+    run(file, args, { cwd, encoding: "utf8" }, (error, stdout) =>
+      error ? reject(error) : resolveResult(stdout),
+    );
+  });
+}

package/templates/.agents/skills/zaip-skill-growth-strategy-revops/SKILL.md

@@ -12,3 +12,5 @@ description: Guide data-driven growth strategy, RevOps decisions, experiments, a
 - Dados e significância exigem método reproduzível; marca, campanha e playbook comercial vão aos respectivos especialistas. Esta skill não autoriza campanha, alteração comercial ou experimento externo.
 
 Uma interaction read-only não materializa Task/Change. Entrega persistente segue lifecycle, Requirements/AC e assurance proporcionais; só trabalho técnico carrega engenharia.
+
+Para resumo salvo ou documento de contexto simples, delimitado e de baixo impacto com fontes fornecidas, use o [perfil editorial `lite`](../zaip-skill-task/SKILL.md#assurance-proporcional) e selecione `--risk lite`. Diagnóstico estratégico, recomendação financeira, experimento, alteração operacional ou ação externa permanecem fora desse perfil.

package/templates/.agents/skills/zaip-skill-hostinger-cloudflare-terraform/SKILL.md

@@ -1,17 +1,25 @@
 ---
 name: zaip-skill-hostinger-cloudflare-terraform
-description: Operate Terraform for scoped Cloudflare DNS and Hostinger VPS with target-bound credentials, state safety, and truthful validation.
+description: Operate scoped Cloudflare/Hostinger Terraform and prepare AWS CLI/Terraform environments with target-bound credentials, state safety, and truthful validation.
 ---
 
-# Terraform Cloudflare e Hostinger
+# Terraform Cloudflare, Hostinger e preparação AWS
 
-Use para criar, importar, ler, alterar ou validar VPS Hostinger e DNS Cloudflare por Terraform. Leia o contrato de infraestrutura indicado pela Task, [o procedimento operacional](references/operational-contract.md) e [o guia do runner autônomo](references/autonomous-runner.md).
+Use para criar, importar, ler, alterar ou validar VPS Hostinger e DNS Cloudflare por Terraform, ou preparar/provisionar AWS com AWS CLI e Terraform dentro de uma Task autorizada. Primeiro escolha o fluxo pela Task:
 
-1. Delimite o perfil `autonomous-cloud`, conta+zona Cloudflare, conta Hostinger, IDs das VPS e fingerprints SSH. Credenciais de dotenv não concedem autoridade nem permitem novo alvo. Use `.env` da raiz primeiro e `.agents/.env` somente quando selecionado pela execução.
+Para alguém iniciando a contratação ou configuração de VPS, comece pelo [guia inicial Hostinger VPS e Terraform](references/guia-iniciante-hostinger-vps.md). Comece pelo estágio já conhecido e faça no máximo três perguntas somente quando faltar contexto; prossiga sem reautorização nas ações já delimitadas. A preferência é a oferta apresentada pela Hostinger como VPS gerenciada por IA; ela facilita o hPanel, terminal Web e assistência Kodee, mas continua sendo VPS KVM com root SSH e administração do cliente. Não peça token de API para o primeiro acesso SSH e não execute ação remota sem a autorização e o contrato exigidos abaixo.
+
+- **Cloudflare/Hostinger:** leia o contrato de infraestrutura indicado pela Task, [o procedimento operacional](references/operational-contract.md) e [o guia do runner autônomo](references/autonomous-runner.md). Preserve o runner existente e seus requisitos.
+- **AWS:** leia somente o contrato AWS declarado na Task e [o contrato AWS CLI/Terraform](references/aws-cli-terraform.md). Não leia, exija ou derive `operational-contract`, `autonomous-runner`, conta/zona Cloudflare, conta/VPS Hostinger ou inputs SSH. Não use `cloud-runner.mjs` para AWS.
+
+1. No fluxo Cloudflare/Hostinger, delimite o perfil `autonomous-cloud`, conta+zona Cloudflare, conta Hostinger, IDs das VPS e fingerprints SSH. Credenciais de dotenv não concedem autoridade nem permitem novo alvo. Use `.env` da raiz primeiro e `.agents/.env` somente quando selecionado pela execução.
    Quando uma Task já registra mandato permanente e o `.env` raiz possui identificadores deliberados, faça descoberta somente de leitura para derivar o contrato de alvo; não exija JSON manual ou reautorização. Não generalize essa exceção a outro projeto.
-2. Aplique `$zaip-skill-local-credentials` e injete a credencial mínima por subprocesso: Cloudflare para DNS, Hostinger para VPS, backend de state quando aplicável, e referência de chave+fingerprint para SSH. Nunca mostre token, senha, state, plano binário ou material de chave.
-3. Cloudflare controla DNS e edge; Hostinger controla apenas VPS. Nunca chame ou modele DNS Hostinger. Preserve Pages como destino web separado da origem VPS.
-4. Exija VPS 1 como ingress público e VPS 2 como aplicação privada. Não exponha Redis, BullMQ, exporters, painéis ou observabilidade; declare transporte privado, firewall e executor de configuração antes de afirmar que existem.
-5. Antes de `apply`, exija backend remoto criptografado, versionado e com locking. Rode `init`, `fmt`, `validate` e plano salvo/revisado. Apply usa somente o plano revisado; importação exige ID explicitamente aprovado e revisão de state sem segredo.
-6. Depois de escrever, faça refresh/read-after-write e testes de DNS, TLS, saúde, negação de portas, isolamento beta/produção e restore. Sem execução observada contra os alvos delimitados, registre somente prova estática/local.
-7. Em criação, confirme nomes, plano, região, template e teto aprovados, vincule IDs observados e verifique fingerprint antes de SSH. Dentro desse escopo, portas aprovadas, firewall, rotação de chave e DNS são autônomos. Troca de conta/zona/VPS/fingerprint, expansão de orçamento, destino ou recurso desconhecido, ou efeito irreversível ainda não aprovado bloqueia até que a Task atualize o escopo.
+2. No fluxo Cloudflare/Hostinger, aplique `$zaip-skill-local-credentials` e injete a credencial mínima por subprocesso: Cloudflare para DNS, Hostinger para VPS, backend de state quando aplicável, e referência de chave+fingerprint para SSH. Nunca mostre token, senha, state, plano binário ou material de chave.
+3. No fluxo Cloudflare/Hostinger, Cloudflare controla DNS e edge; Hostinger controla apenas VPS. Nunca chame ou modele DNS Hostinger. Preserve Pages como destino web separado da origem VPS.
+4. No fluxo Cloudflare/Hostinger, exija VPS 1 como ingress público e VPS 2 como aplicação privada. Não exponha Redis, BullMQ, exporters, painéis ou observabilidade; declare transporte privado, firewall e executor de configuração antes de afirmar que existem.
+5. No fluxo Cloudflare/Hostinger, antes de `apply`, exija backend remoto criptografado, versionado e com locking. Rode `init`, `fmt`, `validate` e plano salvo/revisado. Apply usa somente o plano revisado; importação exige ID explicitamente aprovado e revisão de state sem segredo.
+6. No fluxo Cloudflare/Hostinger, depois de escrever, faça refresh/read-after-write e testes de DNS, TLS, saúde, negação de portas, isolamento beta/produção e restore. Sem execução observada contra os alvos delimitados, registre somente prova estática/local.
+7. No fluxo Cloudflare/Hostinger, em criação, confirme nomes, plano, região, template e teto aprovados, vincule IDs observados e verifique fingerprint antes de SSH. Dentro desse escopo, portas aprovadas, firewall, rotação de chave e DNS são autônomos. Troca de conta/zona/VPS/fingerprint, expansão de orçamento, destino ou recurso desconhecido, ou efeito irreversível ainda não aprovado bloqueia até que a Task atualize o escopo.
+8. No fluxo AWS, delimite `account_id`, região, profile de origem, principal do backend, principal/role do provider, bucket/key S3 e recursos Terraform antes de usar a CLI. SSO é preferível: `aws configure sso`, `aws sso login --profile` e `aws sts get-caller-identity --profile --region`. Profile existente, OIDC ou role já autorizada também podem cumprir o contrato se a identidade STS conferida corresponder; não use profile padrão implícito.
+9. No fluxo AWS, separe o principal que faz bootstrap/inicializa/acessa o backend S3 do principal/role que o provider AWS usa. O contrato deve nomear os dois, suas contas e regiões, e a verificação STS de cada um. Prefira `role_arn` com `source_profile` ou OIDC; se `aws sts assume-role` for inevitável, não exponha stdout de credenciais. Credenciais ou cache SSO não entram em `.env`, backend-config secreto, plano, state, Git ou evidência.
+10. No fluxo AWS, para Terraform >= 1.10, exija bucket e key aprovados, `region` explícita, `encrypt = true` e `use_lockfile = true`. Faça bootstrap zero-environment separado pelo AWS CLI/Terraform autorizado para criar somente o bucket S3 de state, habilitar versionamento, recovery, encryption e lockfile; `terraform init` não cria o bucket. Exija IAM de menor privilégio e procedimento de recuperação; não configure DynamoDB para novo locking. `backend-config` sem segredo pode ser versionado. Sem lockfile, faça bootstrap com `terraform init`, revise o lock gerado e só então use `terraform init -lockfile=readonly`. A preparação executa `fmt`, `validate` e `plan -out` revisável. A Task AWS ativa, explicitamente autorizada, pode cobrir bootstrap e provisionamento AWS delimitado via AWS CLI/Terraform sem confirmação repetida; `apply` somente consome o plano salvo revisado e contrato delimitado.

package/templates/.agents/skills/zaip-skill-hostinger-cloudflare-terraform/agents/openai.yaml

@@ -1,7 +1,6 @@
 interface:
-  display_name: "Terraform Cloudflare Hostinger"
-  short_description: "Opera DNS Cloudflare e VPS Hostinger delimitados"
-  default_prompt: "Use $zaip-skill-hostinger-cloudflare-terraform para validar alvos, state e uma operacao Terraform Cloudflare/Hostinger com evidencias honestas."
+  display_name: "Terraform Cloudflare Hostinger e AWS"
+  short_description: "Prepara AWS e opera Terraform Cloudflare/Hostinger delimitados"
+  default_prompt: "Use $zaip-skill-hostinger-cloudflare-terraform para validar alvos, state e uma operacao Terraform Cloudflare/Hostinger, ou preparar AWS CLI/Terraform com conta, regiao, profile e roles explicitamente delimitados."
 policy:
   allow_implicit_invocation: true
-

package/templates/.agents/skills/zaip-skill-hostinger-cloudflare-terraform/references/aws-cli-terraform.md

@@ -0,0 +1,62 @@
+# Contrato AWS CLI e Terraform
+
+Use este procedimento somente quando a Task AWS ativa e o contrato de infraestrutura declararem explicitamente a conta AWS, a região, o profile de origem, a role alvo quando aplicável, e os recursos Terraform autorizados. Ele prepara um ambiente e produz um plano revisável. A autorização explícita da Task AWS ativa pode cobrir bootstrap e provisionamento somente dos recursos delimitados com AWS CLI/Terraform e o plano salvo revisado; ela não autoriza publicar aplicação nem ampliar conta, região ou role.
+
+## Identidade e escopo
+
+Registre nomes e ARNs, nunca credenciais, cache SSO, tokens STS, `backend-config`, state, plano binário/JSON ou seu conteúdo. O contrato AWS precisa conter:
+
+| Campo | Exigência |
+| --- | --- |
+| Conta | `account_id` de doze dígitos, correspondente à identidade STS observada para cada principal usado. |
+| Região | Uma região explícita para backend e provider; não herdar o profile ou região padrão do computador. |
+| Profile de origem | Nome explícito do profile configurado por SSO ou credencial local já autorizada. |
+| Principal do backend | Profile/role e conta que executam `terraform init` e acessam o bucket S3 de state. |
+| Principal do provider | Profile/role e conta que o provider AWS usa para ler, planejar ou alterar recursos. |
+| Role assumida | ARN, conta destino, política de menor privilégio, duração de sessão e external ID quando o trust policy exigir. |
+| Backend | Bucket, key, região, versionamento, recuperação e política IAM delimitados. |
+
+Um profile autenticado não autoriza a conta inteira. Um ARN novo, região nova, bucket/state key novo, role nova ou qualquer recurso faturável fora da Task exige escopo atualizado.
+
+## Autenticação AWS CLI
+
+SSO é o método preferível. Quando for o método autorizado, configurar somente o profile declarado:
+
+```text
+aws configure sso --profile PERFIL_ORIGEM
+aws sso login --profile PERFIL_ORIGEM
+aws sts get-caller-identity --profile PERFIL_ORIGEM --region REGIAO
+```
+
+Profile existente, OIDC ou uma role já autorizada também são válidos quando sua identidade STS verificada corresponde ao contrato. Confirme que o `Account` retornado corresponde ao `account_id` e registre somente conta, ARN sanitizado e momento. Não use `default` implicitamente. Para provider ou backend que assumem outra role, prefira profile com `role_arn` e `source_profile`, ou OIDC. Se `aws sts assume-role` for inevitável, declare `--role-arn`, `--role-session-name` e `--duration-seconds`, e nunca imprima, registre ou injete seu stdout de credenciais. Verifique a identidade obtida para cada principal; a credencial de backend não pode ser reutilizada como prova da role do provider, nem o contrário.
+
+O profile e as credenciais de sessão ficam no armazenamento local do AWS CLI, fora do repositório. Nunca copie valores de `~/.aws`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` ou `AWS_SESSION_TOKEN` para `.env`, arquivos Terraform, logs ou evidências.
+
+## Backend remoto S3
+
+Para Terraform >= 1.10, o backend S3 deve declarar bucket, key e região aprovados, `encrypt = true` e `use_lockfile = true`. O bucket deve ter versionamento e recuperação definidos; o principal de backend recebe somente as permissões necessárias ao objeto de state e ao arquivo `.tflock`. Não criar configuração nova com locking DynamoDB.
+
+`backend-config` sem segredo pode ser versionado; passe dados secretos somente por arquivo local ignorado ou variáveis de ambiente efêmeras do processo. Não rastreie segredos, state, lockfile remoto, plano binário ou JSON de plano. O comando `terraform init` deve usar a identidade do backend; a configuração `provider "aws"`/`assume_role` deve usar a identidade do provider, declarada e verificada separadamente.
+
+## Bootstrap AWS de ambiente zero
+
+`terraform init` configura e acessa um backend já existente; ele **não cria o bucket S3**. Quando não houver ambiente AWS anterior, uma Task AWS explicitamente autorizada pode executar um bootstrap separado, com AWS CLI/Terraform e apenas contra o `account_id`, região, principal de backend, bucket e key declarados no contrato. Esse bootstrap não lê nem requer o contrato operacional, runner, conta Cloudflare/Hostinger, VPS ou SSH.
+
+Antes de criar, confirme a identidade STS do principal de backend, a conta, a região e que o bucket aprovado ainda não existe. Crie somente o bucket aprovado e configure: versionamento, recuperação documentada e testável (por exemplo retenção/backup e restauração de versão), criptografia do bucket/state, IAM mínimo para o objeto state e `.tflock`, e `use_lockfile = true` no backend Terraform. Registre apenas os nomes/ARNs sanitizados, configurações não secretas, o resultado e a prova de recuperação; nunca state, tokens ou saída de credenciais. Não use DynamoDB para novo locking.
+
+Depois do bootstrap, inicialize o backend com a identidade de backend, revise o lock gerado e somente então execute `terraform init -lockfile=readonly`. O bootstrap não amplia o contrato para recursos de aplicação ou provider. A Task AWS ativa pode cobrir esses recursos somente quando o contrato os delimita e existe plano salvo revisado; não exija uma Task nova ou confirmação repetida para esse mesmo mandato.
+
+## Ciclo Terraform
+
+1. Verificar profile, conta e região do backend via STS. Sem lockfile, fazer bootstrap com `terraform init`, revisar o lock gerado e só então usar `terraform init -lockfile=readonly`.
+2. Verificar profile, role e conta do provider via STS; rodar `terraform fmt -check`, `terraform validate` e `terraform plan -out` em diretório local ignorado.
+3. Revisar o plano, guardar apenas seu hash, versão do Terraform/providers, conta/região/roles sanitizadas e o resultado da política.
+4. Na Task AWS ativa e explicitamente autorizada, `terraform apply` só consome o plano salvo cuja hash foi revisada. A execução AWS CLI/Terraform deve validar contrato, identidades, targets e hash de plano; o `cloud-runner.mjs` Cloudflare/Hostinger não pode ser apresentado como suporte AWS.
+
+Se autenticação, STS, init ou plano falhar, pare e registre diagnóstico sanitizado. Não faça fallback para outra conta/profile/role, nem repita mutações de provider sem reconciliação.
+
+## Fontes oficiais
+
+- [AWS CLI SSO](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html)
+- [Backend S3 do Terraform](https://developer.hashicorp.com/terraform/language/backend/s3)
+- [Boas práticas AWS para backend Terraform](https://docs.aws.amazon.com/prescriptive-guidance/latest/terraform-aws-provider-best-practices/backend.html)

package/templates/.agents/skills/zaip-skill-hostinger-cloudflare-terraform/references/guia-iniciante-hostinger-vps.md

@@ -0,0 +1,183 @@
+# Guia bem mastigado: VPS Hostinger, SSH, Codex e Terraform
+
+Uma **VPS** é um computador Linux alugado; **CPU**, **RAM** e **disco** são sua velocidade, memória e espaço. **SSH** é a conexão segura do seu computador para esse Linux. **Terraform** descreve infraestrutura em arquivos; seu **state** é o registro privado do que ele já administra.
+
+Este guia escolhe a próxima etapa pelo ponto em que a pessoa está. O Codex pode explicar, preparar arquivos locais e validar leitura autorizada, mas não compra, não cria token, não aplica Terraform e não faz deploy sem o escopo da Task. Quando plano, portas e alvos já forem autorizados, ele segue sem pedir a mesma autorização a cada etapa.
+
+## Primeiro: onde você está agora?
+
+1. **Sem VPS:** comece na etapa 1.
+2. **VPS comprada, sem SSH:** comece na etapa 3.
+3. **SSH funcionou duas vezes e a fingerprint foi conferida:** comece na etapa 5.
+
+Se ainda faltar contexto, faça somente estas perguntas: qual aplicação e público? qual teto mensal e quanto pode pagar agora? é uma prova pequena ou a arquitetura aprovada de duas VPS? Reuse fatos já conhecidos e avance automaticamente quando a próxima ação for do Codex e já estiver autorizada.
+
+## 1. Orçamento, tamanho e desenho
+
+**Você faz:** defina um teto que inclua VPS, domínio, backup, serviços externos, impostos e renovação. No checkout, o preço “por mês” pode ser o total antecipado dividido pelos meses. Anote total debitado hoje, período contratado e renovação.
+
+Exemplo fictício, apenas para aprender a comparar:
+
+| Escolha | Mensal equivalente | Débito agora | Renovação mensal equivalente | Conferir |
+| --- | ---: | ---: | ---: | --- |
+| Teste, 12 meses | R$ 35 | R$ 420 | R$ 70 | imposto, domínio, backup |
+| Serviço pequeno, 24 meses | R$ 60 | R$ 1.440 | R$ 145 | custo de 2 VPS, se aplicável |
+
+Comece com 30–50% de folga de RAM e disco para picos, logs e atualizações. É estimativa, não promessa: meça por alguns dias antes de aumentar.
+
+| Caso | Hipótese | Avaliar primeiro | Aumentar quando |
+| --- | --- | --- | --- |
+| Aplicação simples | site/API leve, sem worker contínuo ou banco pesado local | 1–2 vCPU, 4–8 GB RAM, 50–100 GB NVMe | uso sustentado, disco abaixo de 30% livre ou lentidão medida |
+| App + workers + observabilidade | API, tarefas de fundo, métricas e logs | 2–4 vCPU, 8–16 GB RAM, 100–200 GB NVMe | fila cresce, RAM troca para disco ou volume enche |
+| `autonomous-cloud` aprovado | VPS 1 pública + VPS 2 privada | dimensionar e orçar **cada** VPS | nunca reduzir a uma VPS sem novo contrato |
+
+Uma prova pequena pode propor uma VPS em um contrato futuro próprio. O contrato `autonomous-cloud` deste projeto exige VPS 1 como entrada pública e VPS 2 como aplicação privada; Cloudflare controla DNS/edge e Hostinger apenas as VPS.
+
+**Codex faz:** registra as premissas e compara opções, sem inventar preço/capacidade. **Sucesso:** objetivo, região, teto e desenho estão escritos. **Próxima ação:** abrir a página da VPS e anotar checkout, sem pagar. **Retomar:** “retomar orçamento” com plano, período, total e renovação.
+
+## 2. Comprar no hPanel
+
+**Você faz no navegador:**
+
+1. Abra [VPS da Hostinger](https://www.hostinger.com/br/servidor-vps) e prefira a experiência divulgada como VPS gerenciada por IA: hPanel, Terminal Web e Kodee reduzem o atrito inicial.
+2. Escolha plano e período. Veja o total antes de prosseguir; promoção não é previsão de renovação.
+3. Escolha região próxima ao público e um Linux estável suportado pelo projeto. Sem exigência diferente, Ubuntu LTS é uma escolha comum para Docker.
+4. Revise plano, período, região, SO, total, impostos e renovação. Só então faça o pagamento.
+
+“Gerenciada por IA” não é administração terceirizada: continua uma VPS KVM com root SSH, API e responsabilidade sua por sistema, aplicação e dados. Trocar/reinstalar o SO apaga dados e snapshots; não é recuperação casual.
+
+**Codex faz:** confere escolhas contra a Task; não usa cartão. API/MCP são opcionais e não servem para o primeiro SSH. **Sucesso:** hPanel mostra nome/ID, região, IP e SO. **Próxima ação:** em **VPS > Manage > Overview**, anote usuário, IP e porta SSH. **Retomar:** envie dados não secretos ou um screenshot recortado/sem pagamento e segredos.
+
+## 3. Criar a chave SSH no Windows
+
+**LOCAL** é PowerShell no seu Windows. **SERVIDOR** é Terminal Web confiável do hPanel ou SSH autenticado. Nunca rode comando LOCAL no servidor, nem copie chave privada para ele.
+
+**Você faz no PowerShell normal (LOCAL):**
+
+1. Confirme o cliente SSH:
+
+   ```text
+   ssh -V
+   ```
+
+2. Veja se pasta/chave existem; não sobrescreva uma chave:
+
+   ```text
+   Test-Path "$env:USERPROFILE\.ssh"
+   Test-Path "$env:USERPROFILE\.ssh\zaip_hostinger"
+   ```
+
+   Se a pasta não existir:
+
+   ```text
+   New-Item -ItemType Directory -Path "$env:USERPROFILE\.ssh"
+   ```
+
+3. Somente se o segundo teste for `False`, crie a chave. Quando pedir frase secreta, guarde-a localmente:
+
+   ```text
+   ssh-keygen -t ed25519 -a 64 -f "$env:USERPROFILE\.ssh\zaip_hostinger" -C "zaip-hostinger"
+   ```
+
+4. Exiba **somente** a chave pública; o arquivo sem `.pub` é privado:
+
+   ```text
+   Get-Content "$env:USERPROFILE\.ssh\zaip_hostinger.pub"
+   ```
+
+5. No hPanel: **VPS > Manage > Settings > SSH keys > Add**. Cole a linha pública, dê nome e salve.
+
+6. Só se necessário, em **PowerShell como Administrador**, ative o serviço:
+
+   ```text
+   Get-Service ssh-agent | Set-Service -StartupType Automatic
+   Start-Service ssh-agent
+   ```
+
+   Feche o administrador. No PowerShell normal do mesmo usuário que usará SSH/Codex:
+
+   ```text
+   ssh-add "$env:USERPROFILE\.ssh\zaip_hostinger"
+   ```
+
+**Codex faz:** orienta comandos e guarda no máximo o caminho local, nunca chave privada, frase secreta ou token. O `ssh-agent` deve ser da mesma conta/ambiente: PowerShell não prova WSL, cloud ou outra conta. **Sucesso:** painel mostra a chave pública e a privada continua local. **Próxima ação:** conferir identidade do servidor. **Retomar:** envie status/erro sanitizado; chave pública e fingerprint podem ser compartilhadas, privada/frase/token não.
+
+## 4. Conferir identidade e entrar duas vezes
+
+**Você faz:**
+
+1. Em **VPS > Manage > Overview**, copie usuário, IP e porta. Não adivinhe `root` ou porta 22.
+2. Abra Terminal Web no hPanel. No **SERVIDOR**, rode:
+
+   ```text
+   ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
+   ```
+
+   Anote algoritmo e fingerprint.
+3. No **LOCAL**, substitua os dados observados:
+
+   ```text
+   ssh -p PORTA -i "$env:USERPROFILE\.ssh\zaip_hostinger" USUARIO@IP
+   ```
+
+4. Aceite com `yes` somente se algoritmo e fingerprint coincidirem com o Terminal Web. Se divergir, responda `no` e pare.
+5. Rode `exit` e conecte uma segunda vez antes de alterar firewall, senha ou SSH.
+
+**Codex faz:** só fixa a identidade após comparação por canal confiável; `ssh-keyscan` sozinho não autentica servidor. **Sucesso:** duas conexões com a mesma fingerprint. **Próxima ação:** se o Codex tiver permissão, peça a ele uma verificação de leitura; senão reporte o sucesso. **Retomar:** se a fingerprint mudou, não apague `known_hosts`; investigue primeiro no Terminal Web.
+
+## 5. Preparar o Codex para leitura segura
+
+**Você faz:** abra o projeto local correto no Codex e forneça apenas alvo não secreto: alias SSH ou usuário/IP/porta, caminho local da chave e fingerprint confirmada pelos campos previstos na Task. Peça: “Verifique o executor SSH disponível, a compatibilidade da minha chave e, se compatível e autorizado, faça o teste de leitura permitido sem alterar o servidor”. No popup, confira ferramenta e alvo exatos antes de aprovar. Se for útil, envie erro sanitizado ou screenshot recortado, nunca pagamento, token, chave privada ou frase secreta.
+
+Uma aprovação `never` não libera rede. Permissões gerenciadas não podem ser burladas. Não combine `default_permissions` com `sandbox_mode` ou `sandbox_workspace_write`, não crie acesso global total e não presuma que local, WSL e cloud têm a mesma rede/chave.
+
+**Antes do teste pelo runner:** o SSH humano padrão acima pode usar sua chave criptografada e `ssh-agent`. O runner autônomo é diferente: ele aceita somente caminho de chave dentro da raiz do projeto, desativa `IdentityAgent`, usa modo não interativo e não lê sua chave em `%USERPROFILE%\.ssh`; a operação `hostinger:ssh:read` executa somente `uname -s`. Portanto uma chave criptografada externa que funciona no PowerShell **não** deixa o runner pronto. Primeiro o Codex inspeciona essas capacidades e o contrato. Se não existir uma identidade não interativa, protegida e autorizada dentro da raiz, o pré-requisito do runner está pendente; não copie a chave, não remova a frase secreta e não contorne o contrato.
+
+### Opção avançada: chave exclusiva para o runner
+
+Use isto somente se você aceitar uma credencial sem frase secreta para execução não assistida. Nunca retire a frase da sua chave pessoal nem a copie.
+
+1. O Codex confirma `git check-ignore` para `.local/ssh`, permissões/ACL do disco, o host, usuário de deploy e comandos de leitura permitidos.
+2. Ele cria uma **nova** chave de automação em `.local/ssh`, com ACL limitada ao usuário local e disco local criptografado; ela nunca entra em Git ou chat.
+3. Você adiciona somente a nova `.pub` no hPanel ou em `authorized_keys` do usuário de deploy restrito e mantém seu login humano como recuperação.
+4. O Codex testa o runner em modo somente leitura; só então uma Task autorizada pode ampliar o uso.
+
+Se política do host proibir essa chave ou você não aceitar o risco, registre essa escolha e pare: não há atalho. O bootstrap desse usuário/chave é separado do endurecimento de produção.
+
+**Codex faz:** lê configuração efetiva e relata filesystem, rede e ferramentas disponíveis. Para Hostinger/Cloudflare autorizados, usa somente `node .agents/tools/cloud-runner.mjs`, que valida alvo, credencial de origem e fingerprint; hash de plano é exigido apenas para Terraform e hash de script apenas para configuração SSH. Se bloqueado, devolve a mensagem sanitizada exata e a rota suportada, sem atalho. **Sucesso:** o runner conclui `hostinger:ssh:read` no alvo/fingerprint aprovados; não expõe stdout de `uname` nem comprova hostname, `id` ou aplicação. Bloqueio é diagnóstico, não acesso bem-sucedido. **Próxima ação:** aprove apenas o popup previsto ou resolva o pré-requisito informado. **Retomar:** “verificar prontidão SSH” permanece somente leitura e não conecta sem contrato/autorização.
+
+## 6. API/MCP, firewall e configuração
+
+**Você faz:** token não é necessário para SSH. Apenas se houver Task de automação: **hPanel > API** ou **Dev tools > API > Generate API token**, escolha nome/expiração, gere e guarde localmente em `.env` ignorado. Confirme na interface atual o menor escopo; não suponha token limitado a uma VPS. Nunca cole token no chat, Git, Terraform ou state. Após duas conexões, aprove as portas: web costuma precisar 80/443 no ingress aprovado e SSH administrativo limitado; Redis, banco, filas, exporters e painéis ficam privados.
+
+**Codex faz:** prepara Docker/Compose, volumes, usuários, atualização, firewall, logs, healthchecks, limites e rollback. O padrão é Terraform local/runner aprovado e VPS para aplicação; Terraform remoto é tecnicamente possível quando o contrato o declara, protege e justifica. Na arquitetura de duas VPS, prepara transporte privado autenticado VPS 1 → VPS 2. **Sucesso:** há plano de portas, backup e rollback. **Próxima ação:** aprove portas se ainda não estiverem no escopo. **Retomar:** após queda, reconcilie antes de repetir escrita.
+
+## 7. Terraform sem VPS duplicada
+
+**Você faz:** compra manualmente. Se VPS já existe, forneça ID aprovado para adoção/importação; não peça criação “só para testar”. Pare se plano mostrar VPS/DNS/custo inesperado.
+
+**Codex faz:** bloqueia versões de provider, separa state do Git e usa ambiente local/HCP ou backend já aprovado. Não pede JSON de bucket ao leigo. Para S3, backend usa `bucket`, `key`, `region`, `encrypt = true` e `use_lockfile = true`; `terraform init` conecta ao backend existente, não cria bucket. R2 não tem versionamento nativo e exige snapshots/backup protegido e restauração testada. Antes de escrita: `fmt`, `validate`, `plan -out`, revisão do plano salvo e `apply` apenas do arquivo/hash aprovado. Nunca `-lock=false`. **Sucesso:** plano com hash sem segredo e importação ligada à VPS comprada. **Próxima ação:** aprove mudança no escopo quando necessário. **Retomar:** timeout pode criar recurso; consulte provider/state, reconcilie e só então replaineje.
+
+## 8. Provar que está rodando
+
+**Você faz:** defina domínio, manutenção e responsável por backup. Container iniciado não prova serviço pronto.
+
+**Codex faz:** configura DNS Cloudflare, TLS, imagens/digests aprovados, segredos externos, healthchecks, logs e monitoramento. Na topologia aprovada, verifica VPS 1 → VPS 2, isolamento beta/produção e recusa pública de portas privadas. Faz reboot controlado e lê logs. Restaurar pelo painel sobrescreve servidor: teste em cópia/destino isolado; produção só com manutenção autorizada, backup atual e retorno. **Sucesso:** DNS/TLS, endpoint, reboot, logs, backup/restauração segura e portas privadas estão comprovados. **Próxima ação:** escolha frequência de custo, atualização e restore. **Retomar:** peça health, backup, portas e custo com evidência; sem execução observada, o resultado é local/estático.
+
+## Problemas comuns
+
+| Sintoma | Causa provável | Ação segura |
+| --- | --- | --- |
+| `Permission denied (publickey)` | usuário/chave errados ou agente de outra conta | confira Overview e SSH keys; rode `ssh-add` no PowerShell normal; não envie chave privada |
+| Timeout | IP/porta errados, VPS desligada ou firewall | confira Overview/Terminal Web; não abra portas amplas por tentativa |
+| `REMOTE HOST IDENTIFICATION HAS CHANGED` | host mudou ou há risco | pare e compare fingerprint no Terminal Web antes de remover entrada local |
+| erro do agent | serviço não roda no mesmo usuário | configure serviço se preciso como administrador, depois `ssh-add` no usuário normal |
+| Terraform cria VPS comprada | não está no state | pare, confira ID e importe/adote |
+| lock Terraform | outra execução usa state ou falhou | espere/verifique dono e reconcilie; nunca use `-lock=false` |
+
+## Fontes oficiais
+
+- [VPS Hostinger](https://www.hostinger.com/br/servidor-vps), [dashboard hPanel](https://www.hostinger.com/support/5726606-how-to-use-the-vps-dashboard-in-hostinger/) e [chaves SSH](https://www.hostinger.com/support/4792364-how-to-use-ssh-keys-at-hostinger-vps/)
+- [Conexão SSH](https://support.hostinger.com/en/articles/5723772-how-to-connect-to-your-vps-via-ssh), [troca de SO](https://www.hostinger.com/support/4965922-how-to-change-the-operating-system-of-your-vps-at-hostinger/) e [backup/restauração](https://support.hostinger.com/en/articles/1583232-how-to-back-up-or-restore-a-vps)
+- [Provider Terraform Hostinger](https://raw.githubusercontent.com/hostinger/terraform-provider-hostinger/master/docs/resources/vps.md), [OpenSSH no Windows](https://learn.microsoft.com/en-us/windows-server/administration/openssh/openssh_keymanagement)
+- [Configuração](https://learn.chatgpt.com/docs/config-file/config-reference), [segurança](https://learn.chatgpt.com/docs/agent-approvals-security), [permissões do Codex](https://learn.chatgpt.com/docs/permissions), [backend](https://developer.hashicorp.com/terraform/language/backend) e [locking Terraform](https://developer.hashicorp.com/terraform/language/state/locking)

package/templates/.agents/skills/zaip-skill-marketing/SKILL.md

@@ -12,3 +12,5 @@ description: Plan evidence-grounded marketing strategy, copy, campaigns, assets,
 - Para estratégia, planejamento de campanha ou entrega persistente, carregue [o fluxo progressivo](references/extended-workflow.md). Artefatos aprovados vivem em `.agents/marketing/`; `strategy.md` centraliza decisões estratégicas sem duplicação.
 
 Uma interaction read-only não materializa Task/Change. Entrega persistente segue lifecycle, Requirements/AC e assurance proporcionais; só trabalho técnico carrega engenharia.
+
+Para copy pontual, resumo salvo ou organização simples de contexto com fontes fornecidas, use o [perfil editorial `lite`](../zaip-skill-task/SKILL.md#assurance-proporcional): selecione `--risk lite` somente quando o impacto for baixo e não houver código, configuração, ação externa, informação sensível, estratégia crítica ou decisão de marca nova.

package/templates/.agents/skills/zaip-skill-module-scaffold/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: zaip-skill-module-scaffold
+description: Scaffold a safe minimal application module from the declared ZAIP profile and preserve existing work.
+---
+
+# Scaffold a module
+
+Use when a capability needs a new module shell, not to overwrite an existing implementation.
+
+1. Read `.agents/config/project.yaml` and verify that the profile declares a supported relative modules path.
+2. Run `node .agents/skills/zaip-skill-module-scaffold/scripts/scaffold.mjs <name> [--root <root>] [--dry-run]`; read its grammar before automation.
+3. The scaffold rejects traversal, absolute paths, Windows reserved names, case collisions, and paths that resolve through a junction outside the root.
+4. It is idempotent for identical generated files and refuses partial or divergent files; resolve those edits manually with their owner.
+5. Keep the generated domain/application shell free of database and framework imports. Add adapters only after a bounded contract exists and validate the module with its declared test command.