@zaip-ai/cli 6.2.0 → 7.5.0

package/templates/.agents/skills/zaip-skill-infisical/references/first-initialization.md

@@ -0,0 +1,51 @@
+# Primeira inicialização e credencial administrativa
+
+Escolha **usar instância existente** ou **inicializar instância nova**. Uma instância existente mantém usuário, organização, encryption key e identidades; não execute bootstrap para recuperar senha. Use recuperação administrativa da release com backup e autorização próprios.
+
+A [inicialização oficial](https://infisical.com/docs/self-hosting/guides/automated-bootstrapping) pode criar usuário administrador, organização e identidade administradora da instância. O [endpoint](https://infisical.com/docs/api-reference/endpoints/admin/bootstrap-instance) é `POST /api/v1/admin/bootstrap`; o token retornado é secret zero de administração, separado do Universal Auth de leitores/escritores. Nunca copie exemplos upstream que imprimem resposta ou passam senha em argumento.
+
+## Antes de qualquer POST
+
+1. Instância HTTPS exata, TLS normal e acesso restrito; confirme que nunca foi inicializada. Proteja o primeiro cadastro contra terceiros. Se alguém já cadastrou usuário, pare e use a instância existente.
+2. Mandato precisa autorizar **bootstrap**, organização/administrador e o armazenamento privado. Autorização de preparar Compose/DNS não basta. Contrato versionado não contém senha nem token.
+3. Operador gera par RSA de pelo menos 3072 bits fora do contexto do agente. Chave privada cifrada fica no gerenciador de senhas/offline, fora da VPS/cofre; só chave pública PEM e seu SHA-256 revisado entram no contrato. Verifique que o operador consegue recuperar um envelope de teste antes do bootstrap real.
+4. Operador preenche `.agents/private/state/credentials/infisical-admin.env` via editor/secret delivery privado: `INFISICAL_ADMIN_EMAIL`, `INFISICAL_ADMIN_PASSWORD` (mínimo 16 caracteres) e `INFISICAL_ORGANIZATION`. Sem chat, echo, argv ou captura da tela. POSIX: pasta 0700/arquivo 0600. Windows: restrinja ACL ao operador/administradores e registre revisão; o booleano abaixo é recibo humano, não verificação automática de ACL.
+
+Exemplo de contrato `.agents/config/infisical-bootstrap.json` (substitua todos os identificadores antes de executar):
+
+```json
+{
+  "version": 1,
+  "provider": "infisical-self-hosted",
+  "mode": "first-initialization",
+  "origin": "https://secrets.example.com",
+  "authorization": {
+    "approved": true,
+    "operation": "bootstrap",
+    "reference": "mandato-humano-delimitado",
+    "uninitializedInstanceConfirmed": true
+  },
+  "credentialsFile": ".agents/private/state/credentials/infisical-admin.env",
+  "recoveryPublicKey": {
+    "path": ".agents/config/infisical-recovery-public.pem",
+    "sha256": "SHA256_REAL_DA_CHAVE_PUBLICA"
+  },
+  "security": {"windowsCredentialAclReviewed": true}
+}
+```
+
+```text
+node .agents/tools/infisical-bootstrap.mjs --help
+node .agents/tools/infisical-bootstrap.mjs --contract .agents/config/infisical-bootstrap.json --operation validate
+node .agents/tools/infisical-bootstrap.mjs --contract .agents/config/infisical-bootstrap.json --operation bootstrap
+```
+
+`validate` é offline: valida contrato/chave pública e não lê o arquivo de senha, não reserva tentativa e não confirma estado remoto. `bootstrap` autentica o servidor por HTTPS, sem redirect, envia uma única requisição e reserva `.agents/private/state/credentials/infisical-bootstrap/attempt.json` antes dela. Diretório existente bloqueia reenvio, mesmo após 403, timeout ou resposta inválida. Não apague o marcador para tentar novamente: confira remotamente usuário/organização/identidade e recupere a instância com procedimento aprovado. Falha de persistência após sucesso remoto também exige recuperação, nunca novo cadastro.
+
+Saída administrativa completa fica somente em `administrator.sealed.json`: AES-256-GCM, chave de dados envolvida por RSA-OAEP-SHA256. Diagnóstico retorna código fixo; não retorna IDs pessoais, senha, token, prefixo ou hash de segredo. Envelope ainda precisa de backup cifrado e retenção limitada. Strings em memória não têm apagamento garantido; o processo/host permanecem parte da fronteira de confiança.
+
+## Recuperar e encerrar o bootstrap
+
+Em estação privada do operador, compare `context.origin` e `context.contractSha256` com a origem e hash do contrato confiável guardado fora do envelope. Desembrulhe `wrappedKey` com a chave RSA privada/OAEP-SHA256; decifre `ciphertext` com AES-256-GCM usando `iv` e `tag` Base64 e AAD igual aos bytes UTF-8 de `JSON.stringify(context)` (ordem `origin`, `contractSha256`). Contexto divergente bloqueia; não aceite a origem só porque veio junto do envelope. Entregue o JSON decifrado diretamente ao gerenciador de senhas ou processo administrativo autorizado, sem stdout/console/arquivo plaintext. Não peça ao agente para abrir o envelope decifrado. O formato é versionado no helper e seu teste offline verifica round-trip e rejeição de contexto adulterado.
+
+Abra `origin` no navegador confiável e use o e-mail/senha fornecidos; confira organização e painel administrativo. Configure recuperação de acesso/SMTP e MFA disponível. Crie identidades leitor/escritor de projeto conforme [credenciais](credential-workflow.md), prove negações e só então retire a credencial administrativa do ambiente de automação. Revogar token/identidade ou trocar senha é ação administrativa explícita; não confunda apagar o envelope com revogação. A UI e a API podem variar por versão: incompatibilidade bloqueia sem fallback Cloud ou downgrade.

package/templates/.agents/skills/zaip-skill-infisical/references/security-and-edition.md

@@ -0,0 +1,19 @@
+# Segurança e edição
+
+Fontes verificadas em 26/10/2026: [licença/repositório](https://github.com/Infisical/infisical), [self-hosting](https://infisical.com/docs/self-hosting/overview), [Universal Auth](https://infisical.com/docs/documentation/platform/identities/universal-auth). Núcleo MIT; pasta `ee` contém recursos comerciais. Self-hosted não significa todos os recursos gratuitos nem ausência de custo de VPS/backup/operação. Verifique edição/release antes de depender de custom roles, IP restrictions, SSO, approvals, audit retention ou segredos dinâmicos. O baseline não exige essas features pagas.
+
+Rechecagem documental em 27/10/2026: a [licença upstream](https://github.com/Infisical/infisical/blob/main/LICENSE) distingue conteúdo MIT e diretórios `ee`. A [página comercial](https://infisical.com/pricing) anuncia Free com cinco identidades e projetos ilimitados, e self-hosting comercial em Enterprise. Essa tabela não comprova a quota/feature da imagem OSS selecionada. Antes de prometer uso gratuito, registre tag/digest, licença incluída, limite efetivo de humanos/máquinas, roles disponíveis e resultado dos testes de autorização. Não use trial como prova de feature gratuita permanente, nem transponha automaticamente quota Cloud à OSS. Se a edição não oferecer identidade leitora capaz de negar escrita, esse requisito de segurança fica pendente; não conceda Admin como substituto.
+
+| Risco | Controle | Limite |
+| --- | --- | --- |
+| Valor em chat/log/Git | Sem export; cofre/bootstrap protegido e memória do consumidor | Docker/root/admin e processo consumidor podem ler o segredo |
+| Acesso excessivo no free | Projeto por aplicação+ambiente; identidade leitora separada; testes negativos | Pasta não é fronteira sem RBAC correspondente |
+| Secret zero | Bootstrap fora do cofre; client secret protegido/rotacionável | Única chave de recuperação não pode estar dentro do próprio cofre |
+| Exfiltração | HTTPS exato, TLS normal, sem redirects/fallback Cloud | Mandato deve verificar domínio; controles DNS/TLS/egress continuam necessários |
+| Retry/concorrência | Create-only, leitura antes/depois, sem retry automático | Falha depois de POST exige reconciliação |
+| Perda de nó | Banco+chave+imagem, backup cifrado independente, restore testado | Nó único não é HA |
+| Consumidor malicioso | Identidade mínima, revisão do processo, sandbox/egress | Wrapper não torna confiável um programa malicioso |
+
+Strings JS não têm apagamento criptográfico garantido; limite vida do processo/dumps e proteja o host. Novos processos falham fechados na indisponibilidade; processos já iniciados podem manter valores em memória. Documente expiração, revogação e restart. Offline cache exigiria autorização, criptografia/TTL e testes próprios; não é fallback deste runner.
+
+Auditoria ZAIP registra operação/alvo lógico/resultado/momento, nunca valor, tamanho, hash ou prefixo do segredo. Não substitui audit log do cofre. Instalação, autenticação, permissões e uso pelo consumidor são provas distintas.

package/templates/.agents/skills/zaip-skill-infisical/references/self-hosting.md

@@ -0,0 +1,71 @@
+# Instalação self-hosted
+
+Baseline: Compose de nó único com Infisical, PostgreSQL dedicado e Redis dedicado, volumes persistentes e porta somente loopback. Não é HA. Na mesma VPS das aplicações, separe stack, usuários, redes e volumes; aceite o domínio de falha compartilhado. Não reutilize automaticamente Redis de BullMQ ou banco da aplicação. Dimensione CPU/memória/disco pela versão e carga.
+
+Fontes: [Compose oficial](https://infisical.com/docs/self-hosting/deployment-options/docker-compose), [variáveis](https://infisical.com/docs/self-hosting/configuration/envars), [self-hosting/upgrade](https://infisical.com/docs/self-hosting/overview). A receita upstream usa PostgreSQL 14; confirme compatibilidade antes de outro major. Este template espera `/var/lib/postgresql/data`; outros layouts exigem adaptação.
+
+## Preparar sem instalar
+
+Para começar, escolha: **já tenho um cofre** (verifique origin/versão/projeto e siga o contrato de credenciais, sem gerar chaves/Compose), **já tenho VPS** (inventarie/adote explicitamente o host, sem compra/reinstalação) ou **começar do zero** (planeje VPS e orçamento antes de provisionar). Confirme capacidade para o cofre e dependências; [o guia oficial Compose](https://infisical.com/docs/self-hosting/deployment-options/docker-compose) informa mínimo 2 cores/4 GB/20 GB e recomenda 4 cores/8 GB/50 GB+ para seu baseline. Isso não reserva capacidade nem garante disponibilidade para uma VPS que já recebe aplicações.
+
+1. Confirme host Linux aprovado, Docker Engine/Compose v2, capacidade, backup cifrado, rede de gestão, hostname HTTPS e reverse proxy. Scaffold não abre firewall nem altera DNS.
+2. Selecione releases/digests reais compatíveis com a arquitetura do host. Registre release, digest e fonte oficial. O helper exige repositórios `infisical/infisical`, `postgres`, `redis` fixados por digest; não aceita `latest` sem digest.
+3. Crie `.agents/config/infisical-install.json` sem valores secretos; autorização deve refletir pedido humano vigente:
+
+```json
+{
+  "version": 1,
+  "authorization": {"approved": true, "reference": "pedido-ou-contrato-aprovado"},
+  "siteUrl": "https://secrets.example.com",
+  "loopbackPort": 8090,
+  "images": {
+    "infisical": "infisical/infisical:RELEASE@sha256:DIGEST_VERIFICADO",
+    "postgres": "postgres:14-alpine@sha256:DIGEST_VERIFICADO",
+    "redis": "redis:VERSAO@sha256:DIGEST_VERIFICADO"
+  }
+}
+```
+
+```text
+node .agents/skills/zaip-skill-infisical/scripts/prepare-self-host.mjs --request .agents/config/infisical-install.json
+```
+
+Cria `.agents/private/state/infisical-install` uma única vez, exigindo destino ausente. Gera `ENCRYPTION_KEY` 16 bytes hex, `AUTH_SECRET` 32 bytes base64 e senhas independentes PostgreSQL/Redis sem imprimir valores. Não regenera chaves sobre instalação existente. POSIX: pasta 0700, `server.env` 0600 e arquivos bind-mounted 0444 dentro dessa pasta privada para leitura pelos usuários das imagens. No Windows, bits POSIX não provam ACL: restrinja ao proprietário/administradores antes de usar e confira permissões no Linux. Se houver falha parcial, preserve/investigue o diretório antes de nova tentativa.
+
+O bootstrap é secreto: ignore não é criptografia. Mantenha cópia cifrada fora da VPS. Não use `cat`, `docker inspect`, `docker compose config` sem `--quiet` ou logs completos em ferramenta do agente. Não anexe os arquivos a relatórios.
+
+## Implantar no host autorizado
+
+Transfira por canal aprovado preservando permissões para uma pasta privada, por exemplo `/opt/zaip-infisical`. Sob contrato de infraestrutura que autorize a operação:
+
+```text
+docker compose --env-file .env -f compose.yaml config --quiet
+docker compose --env-file .env -f compose.yaml pull
+docker compose --env-file .env -f compose.yaml up -d
+docker compose --env-file .env -f compose.yaml ps
+```
+
+O helper não executa esses comandos. Diante de recusa, não troque transporte nem desligue hook. Não use `down -v`, `volume prune`, senha upstream ou auto-update de imagens.
+
+Confira `/api/status`, três containers saudáveis, persistência e ausência de portas 5432/6379 públicas. Proxy no host alcança loopback; proxy em container exige rede dedicada/adaptação, pois seu `127.0.0.1` não é o host. Configure HTTPS válido e acesso administrativo por rede confiável/VPN/firewall. Não publique 8080 em todas as interfaces.
+
+Faça o primeiro cadastro humano em acesso restrito ou use [bootstrap API one-shot](first-initialization.md) explicitamente autorizado. Não execute ambos como tentativa de fallback. Confira organização, recuperação/SMTP e política de cadastro na UI da release; não invente variável de desabilitar signup. Configure MFA quando disponível. TLS, DNS, login e autorização são evidências separadas.
+
+## Subdomínio, TLS e entrada pelo navegador
+
+1. Escolha um hostname exclusivo na zona aprovada, como `secrets.example.com`. No [setup Cloudflare](../../zaip-skill-cloudflare-access-setup/SKILL.md), identifique conta/zona e o dono do registro. Um registro existente precisa de leitura e adoção explícitas; não crie duplicata nem sobrescreva e-mail/CAA.
+2. Na fundação de duas VPS, o registro A proxied aponta somente ao edge. O cofre roda na VPS privada. Configure proxy privado nessa VPS e upstream do edge pelo túnel autenticado, com firewall permitindo somente o edge e gestão aprovada. O bind loopback do Compose não fica acessível por outro host; nunca o exponha em `0.0.0.0` para resolver isso. Em host único, proxy local pode usar `127.0.0.1:8090`.
+3. Configure certificado de origem compatível com hostname e Full (strict), certificado edge ativo e renovação verificável. Não use Flexible ou `curl -k`. Origin CA funciona com Cloudflare, mas acesso direto por navegador exige certificado confiável pelo navegador. CAA, DNSSEC e ACME continuam etapas próprias; não retire proteção para emitir certificado sem plano.
+4. Restrinja administração antes de publicar DNS: VPN/firewall/allowlist ou controle de acesso previamente configurado. O setup de token não configura Cloudflare Access/Zero Trust. Depois confira resolução autoritativa e recursiva, handshake HTTPS e `/api/status`; sucesso de DNS não prova TLS nem health.
+5. No navegador, abra apenas a URL HTTPS revisada. Se instância nova: conclua cadastro privado ou entre com usuário do bootstrap, sem enviar senha ao agente. Se existente: login normal/recuperação administrativa, sem novo bootstrap. Confirme organização e versão; crie projeto por aplicação/ambiente e identidades conforme [credential-workflow](credential-workflow.md).
+
+**Resultado esperado:** certificado válido, organização correta, leitura autorizada e negativas de escrita/outro projeto pela identidade leitora. **Retomada:** registre hostname, etapa e código sanitizado; não anexe screenshot de token/senha nem logs completos. Pare diante de 403/TLS divergente e corrija o escopo, sem trocar transporte ou desabilitar hook.
+
+## Backup, restore e upgrade
+
+- Backup consistente do PostgreSQL, bootstrap/chave de criptografia e configuração/digests. Saída de backup vai a arquivo protegido, nunca stdout. Banco sozinho não recupera o cofre sem sua chave.
+- Redis tem volume de filas; documente o que a release reconstrói e o que restaura. Defina RPO/RTO, retenção, alertas de disco e teste restore isolado sem egress de integrações.
+- Upgrade exige release notes, compatibilidade, backup restaurável e ensaio. Após migração, voltar só a imagem pode falhar; rollback deve combinar banco, chave e imagem do mesmo ponto. Nunca gire `ENCRYPTION_KEY` editando `.env`.
+- Readiness: TLS, cadastro protegido, leitura autorizada, negativa de escrita pela identidade leitora, negativa de outro projeto/ambiente, uso pelo consumidor sem exposição e restore comprovado. `Up` não basta.
+
+Procedimento de restore: fixe um ponto consistente de banco + `ENCRYPTION_KEY` + configuração e digests; copie backup cifrado para host isolado com egress de integrações negado; restaure o banco e a mesma chave sem alterar a origem de produção; inicie a release correspondente, confira health, login e segredo sintético com identidade limitada; meça perda e duração contra RPO/RTO e registre apenas resultado. Destrua somente a cópia de ensaio sob autorização própria. Sem ensaio bem-sucedido, reporte backup existente e restore não comprovado. Evite backup do diretório de dados ao vivo sem mecanismo consistente; stdout de dump vai diretamente ao destino protegido do executor aprovado.

package/templates/.agents/skills/zaip-skill-infisical/references/terraform.md

@@ -0,0 +1,54 @@
+# Terraform opt-in e host existente
+
+A raiz project-owned `infra/terraform` preserva a arquitetura aprovada de **duas VPS**. O overlay distribuído [infisical.tf](../assets/terraform/infisical.tf) acrescenta somente DNS: requer `local.edge_ipv4`, `cloudflare_zone_id`, `cloudflare_zone_name` e `cloudflare_dns_records` da fundação existente. Não copie sobre arquivo já existente sem revisar seu diff; não o use como módulo independente. Init não habilita o overlay nem instala o cofre.
+
+Instalação nova em uma raiz Terraform vazia recebe a fundação e `infisical.tf` com default `null`. Todo seed em `infra/terraform/` passa a pertencer ao consumidor: repeat e upgrade normal/force preservam bytes existentes, inclusive se um lock antigo os marcava como gerenciados. O novo lock deixa de assumir propriedade desses arquivos. Outros diretórios de infraestrutura mantêm suas políticas.
+
+Upgrade só acrescenta seeds ausentes quando `main.tf`, `variables.tf` e `versions.tf` correspondem por conteúdo/hash à fundação conhecida. O legado reconhecido exige também o hash exato no lock anterior; não basta o nome do arquivo nem um comentário HCL. Em uma raiz customizada/incompatível, o instalador não mistura seeds faltantes: emite aviso e mantém este asset como proposta revisável. Revise variáveis, locals, provider e topologia antes da integração manual autorizada; `null` não evita erros de referências estáticas ausentes. Novas versões do template não substituem alterações do consumidor nem removem seus arquivos extras.
+
+Default `infisical = null` não cria nada. Habilitação explícita em `terraform.tfvars` local ignorado:
+
+```hcl
+infisical = {
+  hostname = "secrets.example.com"
+}
+```
+
+Esse endereço gera um A proxied em `cloudflare_dns_record.infisical[0]`, com origem edge, TTL Auto e proteção contra destruição. Não crie o mesmo hostname na lista genérica nem no runner direto. Registros existentes precisam de inventário e importação explicitamente autorizada no endereço correto; IP fornecido com `manage_vps=false` não é importação de VPS. `prevent_destroy` implica que desabilitar depois de criar exige revisar a remoção; não use destroy para rollback.
+
+## Prévia offline
+
+O contrato não contém senha, chave privada ou token:
+
+```json
+{
+  "version": 1,
+  "enabled": true,
+  "authorization": {"approved": true, "reference": "mandato-aprovado"},
+  "cloudflare": {"accountId": "ACCOUNT_ID_32_HEX", "zoneId": "ZONE_ID_32_HEX", "zoneName": "example.com"},
+  "hostname": "secrets.example.com",
+  "topology": "edge-application-two-vps",
+  "edgeIpv4": "192.0.2.1",
+  "applicationIpv4": "192.0.2.2",
+  "vaultHost": "application",
+  "existingDnsNames": []
+}
+```
+
+IP acima é apenas exemplo reservado. Substitua IDs/IPs pelos alvos observados antes do uso. `existingDnsNames` deve ser inventário completo de nomes já presentes no código/estado/provedor; declaração vazia não comprova ausência remota.
+
+```text
+node .agents/skills/zaip-skill-infisical/scripts/preview-terraform.mjs --contract .agents/config/infisical-infrastructure.json
+```
+
+A prévia verifica consistência e mostra o DNS esperado. Não chama Terraform, não consulta conta, não prepara backend e não é plan/validate do provider. Com `enabled=false`, não exige host/token e declara zero mudanças esperadas para esta extensão.
+
+## Integração executável e limites
+
+Antes de operação real, o contrato do `cloud-runner.mjs` e a política de plano precisam enumerar o hostname em `cloudflare.dns_records`, tipo A, conteúdo edge e proxy; ambos devem concordar com a zona/conta verificadas. O comentário `destination=edge` permite ao validador de plano aplicar a regra de origem edge. Não acrescente hostname ao inventário de escrita direta. Variável `infisical` fica no tfvars revisado; não há variável de token nem provider Infisical.
+
+O runner continua exigindo contrato/backend/hash e os providers da fundação; o overlay não amplia sua permissão nem remove preflight Hostinger de Terraform combinado. Não use Terraform direto para contornar essas exigências. `fmt -check`, `validate` com providers já disponíveis e plano salvo revisado pertencem à validação Terraform; simulação Node não os substitui. Sem provider/binário disponível, reporte o gate como não executado e não baixe/aplique só para produzir evidência.
+
+**Host existente:** inventarie ID e capacidade, confirme dono, serviços, volumes, portas, backup e transporte; use o onboarding modular para preparar adoção. `vps:terraform:prepare` é preparo local, não prova import executável para qualquer topologia. Import VPS da fundação requer contrato explícito, schema da versão instalada e recursos `edge[0]`/`application[0]`; não invente recurso/campo. Não troque `manage_vps` de recurso já ligado ao state para ignorá-lo.
+
+Instalação do cofre é separada: [Compose dedicado](self-hosting.md), TLS, rede privada, cópia protegida de bootstrap e [cadastro inicial](first-initialization.md). Sem provisioner, remote-exec, local-exec, user_data secreto ou chave no state. Deploy de aplicação/compra/conta/DNS não são autorizados por este exemplo. Rollback exige restaurar DNS/configuração próprios pelo executor autorizado e, após migração, o conjunto banco+chave+imagem compatíveis. Nada altera a topologia ou restaura volume por inferência.

package/templates/.agents/skills/zaip-skill-infisical/scripts/prepare-self-host.mjs

@@ -0,0 +1,92 @@
+import { randomBytes } from "node:crypto";
+import { lstat, mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { argumentsFor, fail, localFile, origin } from "../../../tools/infisical-policy.mjs";
+
+const workspace = resolve(import.meta.dirname, "../../../..");
+export async function prepare(request, root = workspace) {
+  if (
+    request.version !== 1 ||
+    request.authorization?.approved !== true ||
+    !request.authorization.reference
+  )
+    fail("authorization_missing");
+  origin(request.siteUrl);
+  for (const [name, repository] of Object.entries({
+    infisical: "infisical/infisical",
+    postgres: "postgres",
+    redis: "redis",
+  })) {
+    if (
+      !new RegExp(`^${repository}(?::[a-zA-Z0-9._-]+)?@sha256:[a-f0-9]{64}$`).test(
+        request.images?.[name] ?? "",
+      )
+    )
+      fail("image_digest_required");
+  }
+  if (
+    !Number.isInteger(request.loopbackPort) ||
+    request.loopbackPort < 1024 ||
+    request.loopbackPort > 65535
+  )
+    fail("invalid_port");
+  // Never replace an existing install or regenerate its encryption key.
+  const base = await realpath(root);
+  const local = resolve(base, ".agents/private/state");
+  await mkdir(local, { recursive: true });
+  if ((await lstat(local)).isSymbolicLink() || (await realpath(local)) !== local)
+    fail("linked_path");
+  const prepared = ".agents/private/state/infisical-install";
+  const output = resolve(base, prepared);
+  await mkdir(output, { mode: 0o700 });
+  const password = randomBytes(32).toString("hex");
+  const redis = randomBytes(32).toString("hex");
+  const files = {
+    ".env": `INFISICAL_IMAGE=${request.images.infisical}\nPOSTGRES_IMAGE=${request.images.postgres}\nREDIS_IMAGE=${request.images.redis}\nLOOPBACK_PORT=${request.loopbackPort}\n`,
+    "server.env": `ENCRYPTION_KEY=${randomBytes(16).toString("hex")}\nAUTH_SECRET=${randomBytes(32).toString("base64")}\nSITE_URL=${request.siteUrl}\nDB_CONNECTION_URI=postgresql://infisical:${password}@db:5432/infisical\nREDIS_URL=redis://:${redis}@redis:6379\nTELEMETRY_ENABLED=false\nDISABLE_UPDATE_CHECK=true\n`,
+    "postgres-password": password,
+    "redis.conf": `bind 0.0.0.0\nprotected-mode yes\nrequirepass ${redis}\nappendonly yes\nmaxmemory-policy noeviction\n`,
+    ".gitignore": "*\n",
+    "compose.yaml": await readFile(resolve(import.meta.dirname, "../assets/compose.yaml"), "utf8"),
+  };
+  // Bind-mounted files must be readable by the image's own non-root user.
+  // Their parent remains 0700; never copy them into a publicly traversable directory.
+  for (const [name, content] of Object.entries(files))
+    await writeFile(resolve(output, name), content, {
+      flag: "wx",
+      mode: ["postgres-password", "redis.conf"].includes(name) ? 0o444 : 0o600,
+    });
+  return {
+    ok: true,
+    prepared,
+    installed: false,
+    requiresHostPermissionsReview: true,
+  };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    const args = argumentsFor(process.argv.slice(2), ["request"]);
+    const request = JSON.parse((await localFile(workspace, args.request)).bytes.toString("utf8"));
+    console.log(JSON.stringify(await prepare(request)));
+  } catch (error) {
+    console.error(
+      JSON.stringify({
+        ok: false,
+        code: [
+          "authorization_missing",
+          "image_digest_required",
+          "invalid_origin",
+          "invalid_port",
+          "linked_path",
+        ].includes(error.safeCode)
+          ? error.safeCode
+          : error.code === "EEXIST"
+            ? "destination_exists"
+            : "prepare_failed",
+      }),
+    );
+    process.exitCode = 1;
+  }
+}

package/templates/.agents/skills/zaip-skill-infisical/scripts/prepare-self-host.test.mjs

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { parseEnv } from "node:util";
+import { prepare } from "./prepare-self-host.mjs";
+
+const request = () => ({
+  version: 1,
+  authorization: { approved: true, reference: "offline fixture" },
+  siteUrl: "https://vault.example.test",
+  images: {
+    infisical: `infisical/infisical:v0.0.0@sha256:${"a".repeat(64)}`,
+    postgres: `postgres:14-alpine@sha256:${"b".repeat(64)}`,
+    redis: `redis:7-alpine@sha256:${"c".repeat(64)}`,
+  },
+  loopbackPort: 8090,
+});
+async function fixture(t) {
+  const root = await mkdtemp(join(tmpdir(), "zaip-infisical-prepare-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  return root;
+}
+test("prepares isolated Compose files and matching random bootstrap secrets without installing", async (t) => {
+  const root = await fixture(t);
+  const result = await prepare(request(), root);
+  assert.equal(result.installed, false);
+  const path = join(root, result.prepared);
+  const settings = parseEnv(await readFile(join(path, "server.env"), "utf8"));
+  assert.match(settings.ENCRYPTION_KEY, /^[a-f0-9]{32}$/);
+  assert.equal(Buffer.from(settings.AUTH_SECRET, "base64").length, 32);
+  const dbPassword = await readFile(join(path, "postgres-password"), "utf8");
+  const redisConfig = await readFile(join(path, "redis.conf"), "utf8");
+  const redisPassword = redisConfig.match(/^requirepass (.+)$/m)[1];
+  assert.equal(new URL(settings.DB_CONNECTION_URI).password, dbPassword);
+  assert.equal(new URL(settings.REDIS_URL).password, redisPassword);
+  assert.notEqual(dbPassword, redisPassword);
+  assert.equal(JSON.stringify(result).includes(dbPassword), false);
+  assert.equal(settings.TELEMETRY_ENABLED, "false");
+  assert.equal(settings.SITE_URL, request().siteUrl);
+  const compose = await readFile(join(path, "compose.yaml"), "utf8");
+  assert.match(compose, /127\.0\.0\.1:\$\{LOOPBACK_PORT/);
+  assert.match(compose, /data: \{internal: true\}/);
+  assert.equal((compose.match(/ports:/g) ?? []).length, 1);
+  assert.equal(await readFile(join(path, ".gitignore"), "utf8"), "*\n");
+  if (process.platform !== "win32") assert.equal((await stat(path)).mode & 0o777, 0o700);
+});
+test("re-running cannot replace encryption keys or existing installation files", async (t) => {
+  const root = await fixture(t);
+  await prepare(request(), root);
+  const path = join(root, ".agents/private/state/infisical-install/server.env");
+  const before = await readFile(path);
+  await assert.rejects(prepare(request(), root), { code: "EEXIST" });
+  assert.deepEqual(await readFile(path), before);
+});
+test("requires authorization, TLS, immutable images and an unprivileged port", async (t) => {
+  const root = await fixture(t);
+  for (const patch of [
+    { authorization: { approved: false } },
+    { siteUrl: "http://vault.example.test" },
+    { images: { ...request().images, infisical: "infisical/infisical:latest" } },
+    { loopbackPort: 80 },
+  ])
+    await assert.rejects(prepare({ ...request(), ...patch }, root));
+  await assert.rejects(stat(join(root, ".agents/private/state/infisical-install")), {
+    code: "ENOENT",
+  });
+});

package/templates/.agents/skills/zaip-skill-infisical/scripts/preview-terraform.mjs

@@ -0,0 +1,70 @@
+import { isIP } from "node:net";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { argumentsFor, fail, localFile } from "../../../tools/infisical-policy.mjs";
+
+const workspace = resolve(import.meta.dirname, "../../../..");
+/** Local target consistency check, not a Terraform plan or remote permission test. */
+export function previewTerraform(c) {
+  if (c?.version !== 1 || typeof c.enabled !== "boolean") fail("invalid_contract");
+  if (!c.enabled) return { ok: true, enabled: false, resourceChanges: [], remoteOperations: false };
+  if (c.authorization?.approved !== true || !c.authorization.reference?.trim())
+    fail("authorization_missing");
+  if (
+    !/^[a-f0-9]{32}$/.test(c.cloudflare?.accountId ?? "") ||
+    !/^[a-f0-9]{32}$/.test(c.cloudflare?.zoneId ?? "") ||
+    !/^(?:[a-z0-9-]+\.)+[a-z0-9-]+$/.test(c.cloudflare?.zoneName ?? "") ||
+    !/^(?:[a-z0-9-]+\.)+[a-z0-9-]+$/.test(c.hostname ?? "") ||
+    !c.hostname.endsWith(`.${c.cloudflare.zoneName}`)
+  )
+    fail("invalid_target");
+  if (
+    c.topology !== "edge-application-two-vps" ||
+    isIP(c.edgeIpv4) !== 4 ||
+    isIP(c.applicationIpv4) !== 4 ||
+    c.edgeIpv4 === c.applicationIpv4 ||
+    c.vaultHost !== "application"
+  )
+    fail("invalid_topology");
+  if (
+    !Array.isArray(c.existingDnsNames) ||
+    c.existingDnsNames.some((n) => typeof n !== "string") ||
+    c.existingDnsNames.includes(c.hostname) ||
+    c.existingDnsNames.includes(c.hostname.slice(0, -c.cloudflare.zoneName.length - 1))
+  )
+    fail("dns_owner_conflict");
+  return {
+    ok: true,
+    enabled: true,
+    remoteOperations: false,
+    terraformValidated: false,
+    tfvars: { infisical: { hostname: c.hostname } },
+    expectedDns: {
+      address: "cloudflare_dns_record.infisical[0]",
+      zone_id: c.cloudflare.zoneId,
+      name: c.hostname,
+      type: "A",
+      content: c.edgeIpv4,
+      proxied: true,
+      ttl: 1,
+    },
+    vaultHost: "application",
+    installed: false,
+  };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    const args = argumentsFor(process.argv.slice(2), ["contract"]);
+    console.log(
+      JSON.stringify(
+        previewTerraform(
+          JSON.parse((await localFile(workspace, args.contract)).bytes.toString("utf8")),
+        ),
+      ),
+    );
+  } catch {
+    console.error(JSON.stringify({ ok: false, code: "terraform_preview_failed" }));
+    process.exitCode = 1;
+  }
+}

package/templates/.agents/skills/zaip-skill-infisical/scripts/preview-terraform.test.mjs

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import { previewTerraform } from "./preview-terraform.mjs";
+
+const contract = () => ({
+  version: 1,
+  enabled: true,
+  authorization: { approved: true, reference: "fixture" },
+  cloudflare: { accountId: "a".repeat(32), zoneId: "b".repeat(32), zoneName: "example.test" },
+  hostname: "vault.example.test",
+  topology: "edge-application-two-vps",
+  edgeIpv4: "192.0.2.1",
+  applicationIpv4: "192.0.2.2",
+  vaultHost: "application",
+  existingDnsNames: [],
+});
+test("opt-in is disabled by default declaration and never creates a host", () => {
+  assert.deepEqual(previewTerraform({ version: 1, enabled: false }).resourceChanges, []);
+  const r = previewTerraform(contract());
+  assert.equal(r.expectedDns.content, "192.0.2.1");
+  assert.equal(r.expectedDns.address, "cloudflare_dns_record.infisical[0]");
+  assert.equal(r.installed, false);
+  assert.equal(r.remoteOperations, false);
+});
+test("foreign zone, duplicate owner, private origin, absent mandate and topology drift are rejected", () => {
+  for (const patch of [
+    { hostname: "vault.other.test" },
+    { existingDnsNames: ["vault"] },
+    { existingDnsNames: ["vault.example.test"] },
+    { edgeIpv4: "192.0.2.2" },
+    { vaultHost: "edge" },
+    { topology: "third-vps" },
+    { authorization: { approved: false } },
+  ])
+    assert.throws(() => previewTerraform({ ...contract(), ...patch }));
+});
+test("distributed overlay matches the project foundation and carries no secret provider or provisioner", async () => {
+  const overlay = await readFile(
+    new URL("../assets/terraform/infisical.tf", import.meta.url),
+    "utf8",
+  );
+  const foundation = await readFile(
+    new URL("../../../../infra/terraform/infisical.tf", import.meta.url),
+    "utf8",
+  );
+  assert.equal(overlay.replace(/\r\n/g, "\n"), foundation.replace(/\r\n/g, "\n"));
+  assert.equal((overlay.match(/resource "/g) ?? []).length, 1);
+  assert.match(overlay, /default\s+= null/);
+  assert.doesNotMatch(overlay, /resource "(?:hostinger|infisical)|provisioner\s+"|user_data\s*=/);
+});

package/templates/.agents/skills/zaip-skill-infisical/scripts/terraform-plan-integration.test.mjs

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execute = promisify(execFile);
+const root = fileURLToPath(new URL("../../../../", import.meta.url));
+async function fixture(t) {
+  const directory = await mkdtemp(join(tmpdir(), "zaip-vault-plan-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const plan = JSON.parse(
+    await readFile(join(root, "infra/terraform/fixtures/plan-approved.json"), "utf8"),
+  );
+  const contract = JSON.parse(
+    await readFile(join(root, "infra/terraform/fixtures/approved-targets.json"), "utf8"),
+  );
+  const record = {
+    zone_id: contract.cloudflare.zone_id,
+    name: "secrets.example.com",
+    type: "A",
+    content: contract.cloudflare.edge_ipv4,
+    proxied: true,
+    ttl: 1,
+    comment: "Managed by Zaip Terraform; destination=edge; optional Infisical ingress",
+  };
+  plan.resource_changes.push({
+    address: "cloudflare_dns_record.infisical[0]",
+    type: "cloudflare_dns_record",
+    change: { actions: ["create"], after: record },
+  });
+  contract.cloudflare.dns_records[record.name] = {
+    type: "A",
+    content: record.content,
+    proxied: true,
+  };
+  return {
+    plan,
+    contract,
+    record,
+    async run() {
+      const planPath = join(directory, "plan.json"),
+        contractPath = join(directory, "contract.json");
+      await writeFile(planPath, JSON.stringify(plan));
+      await writeFile(contractPath, JSON.stringify(contract));
+      return execute(
+        process.execPath,
+        [
+          ".agents/tools/cloud-terraform-plan-policy.mjs",
+          "--plan",
+          planPath,
+          "--contract",
+          contractPath,
+        ],
+        { cwd: root, windowsHide: true, env: {} },
+      );
+    },
+  };
+}
+test("existing plan policy accepts explicitly inventoried optional vault DNS on edge", async (t) => {
+  const f = await fixture(t);
+  assert.match((await f.run()).stdout, /Validated Terraform plan policy/);
+});
+test("existing plan policy rejects unapproved vault DNS, private origin and destruction", async (t) => {
+  for (const mutate of [
+    (f) => {
+      delete f.contract.cloudflare.dns_records[f.record.name];
+    },
+    (f) => {
+      f.record.content = f.contract.hostinger.application.ipv4;
+    },
+    (f) => {
+      f.plan.resource_changes.at(-1).change.actions = ["delete"];
+    },
+  ]) {
+    const f = await fixture(t);
+    mutate(f);
+    await assert.rejects(f.run(), /Terraform plan policy rejected/);
+  }
+});

package/templates/.agents/skills/zaip-skill-landing-page-forms/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: zaip-skill-landing-page-forms
+description: "Create, improve or audit landing-page forms, selecting a suitable single-screen or staged journey with accessible recovery and verified submission semantics."
+---
+
+# Landing-page forms
+
+Use for a new LP form or a change to its fields, steps, validation, submission or recovery.
+For a visual-only edit, verify the affected render without demanding unchanged integrations.
+
+1. Read the project stack, design contract, current API response and business-owned
+   field/qualification rules. Audit first when the existing behavior is uncertain.
+2. Choose single-screen, multistep or contact-then-qualification using
+   [the decision guide](references/journey.md). Do not impose BANT, a field count or
+   a modal. Keep original layout/content unless the requested change authorizes it.
+3. Write the states and contracts using [submission and privacy](references/contracts.md)
+   and [accessibility](references/accessibility.md). Persistence is independent of
+   navigation. A timeout is uncertain, not proof of failure or permission to duplicate.
+4. Compose existing [API contracts](../zaip-skill-api-contracts/SKILL.md),
+   [frontend data flows](../zaip-skill-frontend-data-flows/SKILL.md) and
+   [lead measurement](../zaip-skill-lead-measurement/SKILL.md). Use existing CRM/Sales
+   contracts; this skill defines no replacement attribution, delivery or CRM engine.
+5. Adapt one of the synthetic [examples](references/examples.md). Validate declarations:
+   `node .agents/skills/zaip-skill-landing-page-forms/scripts/validate-plan.mjs PLAN.json`.
+   Exit 0 means plan coherence only; it proves no live persistence, lawful consent,
+   security, accessibility or conversion. Exit 1 emits sanitized issue codes/paths.
+6. Implement only inside the authorized Task scope. No SQL, webhook, provider change,
+   account access, submission to real people or publication follows from this skill.
+7. Use [verification](references/verification.md): exercise relevant state transitions
+   against the controlled API contract, keyboard/focus and affected responsive render.
+   Separate observed local tests from provider/database/browser capabilities unavailable.
+
+Report chosen format and reason, fields/purposes, state/recovery contract, evidence,
+remaining unknowns and rollback. Never report a redirect, HTTP 2xx or existing contact
+as a newly confirmed Lead without the business/API contract proving that result.
+Measurement may be unused or follow a different explicitly approved, versioned request
+definition; do not universalize the historical example's new-registration-only rule.

package/templates/.agents/skills/zaip-skill-landing-page-forms/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Landing Page Forms"
+  short_description: "Design and improve single-screen and multistep forms"
+  default_prompt: "Use $zaip-skill-landing-page-forms to create or improve a landing-page form with the appropriate format and verified submission contract."