@zaip-ai/cli 6.3.0 → 7.5.0

package/templates/.agents/skills/zaip-skill-google-tag-manager/scripts/google-runbooks.test.mjs

@@ -0,0 +1,247 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { test } from "node:test";
+import {
+  inspectAds,
+  inspectDraft,
+  inspectGa4,
+  measurementProtocolEvidence,
+  simulateOperator,
+} from "./operator-model.mjs";
+
+const fixture = JSON.parse(
+  await readFile(new URL("../references/operator-fixtures.json", import.meta.url), "utf8"),
+);
+const fresh = () => structuredClone(fixture);
+const accepted = (f, override = {}) => ({
+  kind: "accept",
+  persisted: true,
+  message: { ...f.message },
+  ...override,
+});
+const trace = (f) => [{ kind: "load" }, { kind: "navigation" }, accepted(f)];
+
+test("operator starts from synthetic page/export and one chosen import route", () => {
+  const f = fresh();
+  assert.equal(f.synthetic, true);
+  assert.equal(f.importable, false);
+  const result = simulateOperator(f, trace(f));
+  assert.deepEqual(result.errors, []);
+  assert.deepEqual(
+    result.requests.map((item) => item.kind),
+    ["loader", "page_view", "ga4"],
+  );
+  assert.equal(result.model_only, true);
+  assert.equal(inspectDraft(f.export_snapshot, f.draft).published, false);
+});
+test("two loaders or two SPA pageview origins cannot pass the draft", () => {
+  for (const field of ["loaders", "page_view_sources"]) {
+    const f = fresh();
+    f.page[field].push(field === "loaders" ? "direct_gtag" : "custom");
+    const result = simulateOperator(f, trace(f));
+    assert.ok(result.errors.length);
+    assert.equal(result.requests.length, 0);
+  }
+  const f = fresh();
+  const result = simulateOperator(f, [{ kind: "load" }, { kind: "load" }, { kind: "navigation" }]);
+  assert.deepEqual(
+    result.requests.map((item) => item.kind),
+    ["loader", "page_view"],
+  );
+});
+test("unknown denied revoked block all modeled loader/base events and retry effects", () => {
+  for (const state of ["unknown", "denied", "revoked"]) {
+    const f = fresh();
+    f.page.initial_consent = { analytics: state, google_ads: state, revision: 1 };
+    assert.deepEqual(
+      simulateOperator(f, [
+        ...trace(f),
+        { kind: "base" },
+        { kind: "autoevent" },
+        { kind: "noscript" },
+        accepted(f),
+      ]).requests,
+      [],
+    );
+  }
+  const f = fresh();
+  const result = simulateOperator(f, [
+    { kind: "load" },
+    accepted(f),
+    { kind: "consent", analytics: "revoked", google_ads: "revoked", revision: 2 },
+    { kind: "navigation" },
+    { kind: "base" },
+    { kind: "autoevent" },
+    { kind: "noscript" },
+    accepted(f, { message: { ...f.message, event_id: "evt_synthetic_retry_02" } }),
+  ]);
+  assert.deepEqual(
+    result.requests.map((item) => item.kind),
+    ["loader", "ga4"],
+  );
+  assert.deepEqual(
+    simulateOperator(f, [
+      { kind: "load" },
+      { kind: "base" },
+      { kind: "autoevent" },
+      { kind: "noscript" },
+    ]).requests.map((item) => item.kind),
+    ["loader", "base", "autoevent", "noscript"],
+  );
+});
+test("default denied does not authorize cookieless or omit noscript inventory", () => {
+  const f = fresh();
+  f.page.consent_mode = "advanced_cookieless";
+  assert.ok(simulateOperator(f, trace(f)).errors.includes("cookieless_outside_model"));
+  f.page.consent_mode = "basic_blocked";
+  f.page.inventory = ["loader", "base", "autoevents"];
+  assert.ok(simulateOperator(f, trace(f)).errors.includes("loader_inventory_incomplete"));
+});
+test("DLVv2 must not inherit omitted values from a previous message", () => {
+  const f = fresh(),
+    partial = { ...f.message, event_id: "evt_synthetic_google_02" };
+  delete partial.budget_band;
+  const result = simulateOperator(f, [
+    { kind: "load" },
+    accepted(f),
+    accepted(f, { message: partial }),
+  ]);
+  assert.equal(result.requests.filter((item) => item.kind === "ga4").length, 1);
+  assert.ok(result.errors.includes("complete_projection_required"));
+});
+test("rejected backend never becomes a lead; replay is one event and changed payload conflicts", () => {
+  const f = fresh();
+  const result = simulateOperator(f, [
+    { kind: "load" },
+    accepted(f, { persisted: false }),
+    accepted(f),
+    accepted(f),
+    accepted(f, { message: { ...f.message, service: "painting" } }),
+  ]);
+  assert.equal(result.requests.filter((item) => item.kind === "ga4").length, 1);
+  assert.ok(result.errors.includes("conflicting_replay"));
+});
+test("PII or split/free-text projection is rejected before modeled request", () => {
+  for (const change of [
+    (message) => {
+      message.email = "synthetic@example.invalid";
+    },
+    (message) => {
+      message.service = "please call a synthetic person";
+    },
+  ]) {
+    const f = fresh();
+    change(f.message);
+    const result = simulateOperator(f, trace(f));
+    assert.equal(result.requests.filter((item) => item.kind === "ga4").length, 0);
+    assert.ok(result.errors.includes("complete_projection_required"));
+  }
+});
+test("stale fingerprint resource mismatch or overwrite cannot silently replace workspace", () => {
+  for (const override of [
+    { fingerprint: "synthetic_stale" },
+    { container: "synthetic_other" },
+    { mode: "overwrite" },
+  ]) {
+    const f = fresh();
+    const result = inspectDraft(f.export_snapshot, { ...f.draft, ...override });
+    assert.equal(result.ready, false);
+    assert.equal(result.published, false);
+  }
+  const f = fresh(),
+    merged = inspectDraft(f.export_snapshot, f.draft);
+  assert.deepEqual(merged.removed, []);
+  const overwrite = inspectDraft(f.export_snapshot, {
+    ...f.draft,
+    mode: "overwrite",
+    overwrite_reviewed: true,
+  });
+  assert.deepEqual(overwrite.removed, ["synthetic_old_tag"]);
+});
+test("create_version changes workspace and requires verified compiler/sync response", () => {
+  const f = fresh();
+  const result = inspectDraft(f.export_snapshot, f.draft, f.version_response);
+  assert.equal(result.ready, true);
+  assert.equal(result.next_workspace, f.version_response.newWorkspacePath);
+  assert.notEqual(result.next_workspace, f.draft.workspace);
+  assert.equal(result.published, false);
+  for (const response of [
+    { compilerError: true },
+    { ...f.version_response, syncStatusVerified: false },
+    { ...f.version_response, newWorkspacePath: null },
+  ])
+    assert.equal(inspectDraft(f.export_snapshot, f.draft, response).ready, false);
+});
+test("dimensions use the property's observed quota, boundary and edition, not global defaults", () => {
+  const f = fresh();
+  assert.deepEqual(inspectGa4(f.ga4), []);
+  f.ga4.quota_snapshot.used = 48;
+  assert.ok(inspectGa4(f.ga4).includes("property_quota_exceeded"));
+  f.ga4.existing_dimensions = ["service"];
+  assert.deepEqual(inspectGa4(f.ga4), []);
+  f.ga4.edition = "360";
+  f.ga4.quota_snapshot = { property: f.ga4.property, event_dimension_limit: 125, used: 122 };
+  f.ga4.existing_dimensions = [];
+  assert.deepEqual(inspectGa4(f.ga4), []);
+  f.ga4.quota_snapshot.property = "synthetic_other";
+  assert.ok(inspectGa4(f.ga4).includes("property_quota_required"));
+  f.ga4.quota_snapshot = null;
+  assert.ok(inspectGa4(f.ga4).includes("property_quota_required"));
+});
+test("IDs are not dimensions; MP needs a real requirement and 2xx/debug never proves ingestion", () => {
+  const f = fresh();
+  f.ga4.requested_dimensions.push("event_id");
+  assert.ok(inspectGa4(f.ga4).includes("cardinality_or_unknown_dimension"));
+  f.ga4.mp_enabled = true;
+  assert.ok(inspectGa4(f.ga4).includes("mp_requirement_required"));
+  assert.deepEqual(measurementProtocolEvidence(204, true), {
+    transport_2xx: true,
+    debug_schema_valid: true,
+    ingestion_confirmed: false,
+    attributed: false,
+  });
+});
+test("Ads direct/import are exclusive per action and secondary custom goal can still bid", () => {
+  const f = fresh();
+  f.ads.sources_by_fact.lead_accepted = "direct";
+  for (const action of f.ads.actions) action.primary = action.source === "direct";
+  const direct = simulateOperator(f, trace(f));
+  assert.deepEqual(direct.errors, []);
+  assert.equal(direct.requests.filter((item) => item.kind === "ads_direct").length, 1);
+  f.ads.actions[0].primary = true;
+  assert.ok(inspectAds(f.ads).includes("duplicate_or_wrong_primary"));
+  f.ads.actions[0].primary = false;
+  f.ads.goal_mode = "custom";
+  f.ads.custom_goal_action_ids = [f.ads.actions[0].id, f.ads.actions[1].id];
+  assert.ok(inspectAds(f.ads).includes("duplicate_effective_fact"));
+  f.ads.actions[0].currency = null;
+  assert.ok(inspectAds(f.ads).includes("action_decision_incomplete"));
+});
+test("registration and qualification may have distinct primaries with different sources", () => {
+  const f = fresh();
+  f.ads.sources_by_fact = { lead_accepted: "direct", lead_qualified: "ga4_import" };
+  for (const action of f.ads.actions) action.primary = action.source === "direct";
+  f.ads.actions.push({
+    ...f.ads.actions[0],
+    id: "synthetic_qualified_import",
+    fact: "lead_qualified",
+    primary: true,
+  });
+  assert.deepEqual(inspectAds(f.ads), []);
+  const result = simulateOperator(f, trace(f));
+  assert.deepEqual(result.errors, []);
+  assert.equal(result.requests.filter((item) => item.kind === "ads_direct").length, 1);
+  f.ads.actions.at(-1).source = "direct";
+  assert.ok(inspectAds(f.ads).includes("duplicate_or_wrong_primary"));
+});
+test("a secondary custom-goal action is considered by source and fact, not forbidden by its label", () => {
+  const f = fresh();
+  f.ads.goal_mode = "custom";
+  f.ads.actions.push({ ...f.ads.actions[0], id: "synthetic_secondary_import", primary: false });
+  f.ads.custom_goal_action_ids = ["synthetic_secondary_import"];
+  assert.deepEqual(inspectAds(f.ads), []);
+  f.ads.custom_goal_action_ids.push(f.ads.actions[0].id);
+  assert.ok(inspectAds(f.ads).includes("duplicate_effective_fact"));
+  f.ads.custom_goal_action_ids = [f.ads.actions[1].id];
+  assert.ok(inspectAds(f.ads).includes("wrong_goal_source"));
+});

package/templates/.agents/skills/zaip-skill-google-tag-manager/scripts/operator-model.mjs

@@ -0,0 +1,221 @@
+// Offline assessment of normalized synthetic operator snapshots, never a tag/SDK adapter.
+export function inspectAds(ads) {
+  const errors = [];
+  const facts = new Set([
+    ...Object.keys(ads.sources_by_fact ?? {}),
+    ...ads.actions.map((action) => action.fact),
+  ]);
+  if (!["standard", "custom"].includes(ads.goal_mode)) errors.push("goal_mode_required");
+  if (
+    ads.goal_mode === "custom" &&
+    (!ads.custom_goal_action_ids.length ||
+      ads.custom_goal_action_ids.some((id) => !ads.actions.some((action) => action.id === id)))
+  )
+    errors.push("custom_goal_action_required");
+  // In a selected custom goal, secondary actions participate too; do not silently
+  // union account primaries into a custom goal that did not select those actions.
+  const effective =
+    ads.goal_mode === "custom"
+      ? ads.actions.filter((action) => ads.custom_goal_action_ids.includes(action.id))
+      : ads.actions.filter((action) => action.primary);
+  for (const fact of facts) {
+    const source = ads.sources_by_fact?.[fact];
+    if (!["direct", "ga4_import"].includes(source)) errors.push("ads_source_required");
+    const primaries = ads.actions.filter((action) => action.fact === fact && action.primary);
+    if (primaries.length !== 1 || primaries[0].source !== source)
+      errors.push("duplicate_or_wrong_primary");
+    const selected = effective.filter((action) => action.fact === fact);
+    if (selected.length > 1) errors.push("duplicate_effective_fact");
+    if (selected.length === 1 && selected[0].source !== source) errors.push("wrong_goal_source");
+  }
+  if (new Set(ads.actions.map((action) => action.id)).size !== ads.actions.length)
+    errors.push("duplicate_action_id");
+  for (const action of ads.actions) {
+    if (
+      !action.category ||
+      !["one", "every"].includes(action.counting) ||
+      !Number.isFinite(action.value) ||
+      action.value < 0 ||
+      !/^[A-Z]{3}$/.test(action.currency) ||
+      !Number.isInteger(action.window_days) ||
+      action.window_days <= 0 ||
+      !action.attribution
+    )
+      errors.push("action_decision_incomplete");
+  }
+  return errors;
+}
+export function inspectGa4(ga4) {
+  const errors = [],
+    quota = ga4.quota_snapshot;
+  if (
+    !["standard", "360"].includes(ga4.edition) ||
+    !quota ||
+    quota.property !== ga4.property ||
+    !Number.isSafeInteger(quota.event_dimension_limit) ||
+    !Number.isSafeInteger(quota.used) ||
+    quota.used < 0 ||
+    quota.event_dimension_limit < quota.used
+  )
+    return ["property_quota_required"];
+  if (
+    ga4.requested_dimensions.some(
+      (name) => !["service", "budget_band", "qualification"].includes(name),
+    )
+  )
+    errors.push("cardinality_or_unknown_dimension");
+  const count = new Set(
+    ga4.requested_dimensions.filter((name) => !ga4.existing_dimensions.includes(name)),
+  ).size;
+  if (quota.used + count > quota.event_dimension_limit) errors.push("property_quota_exceeded");
+  if (ga4.mp_enabled && !ga4.approved_mp_requirement) errors.push("mp_requirement_required");
+  return errors;
+}
+export function inspectPage(page) {
+  const errors = [];
+  if (page.loaders.length !== 1) errors.push("one_loader_required");
+  if (
+    page.page_view_sources.length !== 1 ||
+    !["enhanced_history", "custom"].includes(page.page_view_sources[0])
+  )
+    errors.push("one_page_view_source_required");
+  if (!page.csp_reviewed) errors.push("csp_review_required");
+  if (["loader", "base", "autoevents", "noscript"].some((item) => !page.inventory.includes(item)))
+    errors.push("loader_inventory_incomplete");
+  if (page.consent_mode !== "basic_blocked") errors.push("cookieless_outside_model");
+  return errors;
+}
+export function inspectDraft(snapshot, draft, versionResponse = null) {
+  const errors = [];
+  if (["account", "container", "workspace"].some((key) => snapshot[key] !== draft[key]))
+    errors.push("resource_mismatch");
+  if (!/^[a-f0-9]{64}$/.test(snapshot.backup_digest ?? "")) errors.push("backup_required");
+  if (!snapshot.fingerprint || draft.fingerprint !== snapshot.fingerprint)
+    errors.push("concurrent_change_reread");
+  if (
+    !["merge", "overwrite"].includes(draft.mode) ||
+    (draft.mode === "overwrite" && !draft.overwrite_reviewed)
+  )
+    errors.push("overwrite_requires_review");
+  const ids = draft.objects.map((item) => item.id);
+  if (new Set(ids).size !== ids.length) errors.push("duplicate_object_id");
+  let nextWorkspace = draft.workspace;
+  if (versionResponse) {
+    // This is a normalized fixture, not Google's raw syncStatus schema.
+    if (
+      versionResponse.compilerError !== false ||
+      versionResponse.syncStatusVerified !== true ||
+      typeof versionResponse.newWorkspacePath !== "string" ||
+      !versionResponse.newWorkspacePath
+    )
+      errors.push("version_response_unverified");
+    else nextWorkspace = versionResponse.newWorkspacePath;
+  }
+  const removed =
+    draft.mode === "overwrite"
+      ? snapshot.objects.filter((item) => !ids.includes(item.id)).map((item) => item.id)
+      : [];
+  return {
+    ready: errors.length === 0,
+    errors,
+    removed,
+    next_workspace: nextWorkspace,
+    published: false,
+  };
+}
+export function measurementProtocolEvidence(status, debugValid) {
+  return {
+    transport_2xx: Number.isInteger(status) && status >= 200 && status < 300,
+    debug_schema_valid: debugValid === true,
+    ingestion_confirmed: false,
+    attributed: false,
+  };
+}
+export function simulateOperator(config, trace) {
+  const errors = [
+    ...inspectPage(config.page),
+    ...inspectGa4(config.ga4),
+    ...inspectAds(config.ads),
+  ];
+  const requests = [],
+    seen = new Map();
+  if (errors.length) return { errors, requests, model_only: true };
+  let current = { ...config.page.initial_consent },
+    loaded = false;
+  const registrationSource = config.ads.sources_by_fact.lead_accepted;
+  const enabled = (purpose) => current[purpose] === "granted";
+  for (const step of trace) {
+    if (step.kind === "consent") {
+      if (
+        !Number.isSafeInteger(step.revision) ||
+        step.revision <= current.revision ||
+        [step.analytics, step.google_ads].some(
+          (value) => !["unknown", "denied", "revoked", "granted"].includes(value),
+        )
+      ) {
+        errors.push("consent_update_unverified");
+        current = { analytics: "unknown", google_ads: "unknown", revision: current.revision };
+      } else
+        current = {
+          analytics: step.analytics,
+          google_ads: step.google_ads,
+          revision: step.revision,
+        };
+      continue;
+    }
+    if (step.kind === "load") {
+      if (
+        !loaded &&
+        (enabled("analytics") || (registrationSource === "direct" && enabled("google_ads")))
+      ) {
+        loaded = true;
+        requests.push({ kind: "loader" });
+      }
+      continue;
+    }
+    if (step.kind === "navigation") {
+      if (loaded && enabled("analytics"))
+        requests.push({ kind: "page_view", source: config.page.page_view_sources[0] });
+      continue;
+    }
+    if (["base", "autoevent", "noscript"].includes(step.kind)) {
+      if (enabled("analytics") && (loaded || step.kind === "noscript"))
+        requests.push({ kind: step.kind });
+      continue;
+    }
+    if (step.kind !== "accept" || step.persisted !== true) continue;
+    const message = step.message;
+    const keys = ["event", "event_id", "service", "budget_band", "qualification"];
+    if (
+      !message ||
+      keys.some((key) => !Object.hasOwn(message, key)) ||
+      Object.keys(message).some((key) => !keys.includes(key)) ||
+      message.event !== "lead_accepted" ||
+      !/^evt_[A-Za-z0-9_-]{8,96}$/.test(message.event_id) ||
+      ["service", "budget_band", "qualification"].some(
+        (key) => !config.catalog[key].includes(message[key]),
+      )
+    ) {
+      errors.push("complete_projection_required");
+      continue;
+    }
+    const fingerprint = JSON.stringify(keys.map((key) => message[key]));
+    if (seen.has(message.event_id)) {
+      if (seen.get(message.event_id) !== fingerprint) errors.push("conflicting_replay");
+      continue;
+    }
+    if (!loaded) continue;
+    let emitted = false;
+    if (enabled("analytics")) {
+      requests.push({ kind: "ga4", event: "generate_lead", event_id: message.event_id });
+      emitted = true;
+    }
+    if (registrationSource === "direct" && enabled("google_ads")) {
+      requests.push({ kind: "ads_direct", event_id: message.event_id });
+      emitted = true;
+    }
+    // ga4_import is a future account-side operation, never a second direct tag.
+    if (emitted) seen.set(message.event_id, fingerprint);
+  }
+  return { errors, requests, model_only: true };
+}

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

@@ -5,10 +5,16 @@ description: Operate scoped Cloudflare/Hostinger Terraform and prepare AWS CLI/T
 
 # Terraform Cloudflare, Hostinger e preparação AWS
 
-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:
+Use para criar, importar, ler, alterar ou validar VPS Hostinger e DNS Cloudflare por Terraform ou pelo runner delimitado, ou preparar/provisionar AWS com AWS CLI e Terraform dentro de uma Task autorizada. Primeiro escolha o fluxo pela Task:
+
+- **Setup do agente Cloudflare:** consulte [skills, MCP e CLI oficiais](references/cloudflare-agent-setup.md), preservando instalações existentes e distinguindo documentação pública de operações autenticadas.
+- **Conta e token DNS/Pages:** use [Cloudflare access setup](../zaip-skill-cloudflare-access-setup/SKILL.md), com conta/zona/projeto e fonte privada explícitos; não confunda com Cloudflare Access/Zero Trust.
+- **DNS/edge/domínios:** consulte [o contrato DNS e as provas de TLS/domínio](references/cloudflare-dns.md). DNS-only exige apenas os alvos/credenciais Cloudflare da operação; não exige Hostinger ou Terraform. Não use o preflight combinado de duas VPS para esta etapa.
 
 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.
 
+Para onboarding de VPS existente, referência externa, agente selecionado, importação/geração local, confiança e inventário, use primeiro [o procedimento modular executável](references/vps-onboarding.md). Ele usa operações `vps:*` independentes no runner; não exige conta/zona Cloudflare, token Hostinger, backend Terraform nem segunda VPS para SSH. Os contratos legados abaixo continuam aplicáveis somente à operação de provedor/Terraform correspondente.
+
 - **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.
 
@@ -16,7 +22,7 @@ Para alguém iniciando a contratação ou configuração de VPS, comece pelo [gu
    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. 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.
+4. Use a topologia escolhida no principal de arquitetura do consumidor, com um ou vários hosts. Se ela declarar duas VPS, preserve a separação ingress/aplicação; nenhuma etapa exige outra VPS apenas para satisfazer um schema. Não exponha Redis, BullMQ, exporters, painéis ou observabilidade; declare isolamento, firewall e executor antes de afirmar que existem. Adote servidores existentes por ID verificado; criação, reinstalação ou substituição exigem autoridade própria.
 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.

package/templates/.agents/skills/zaip-skill-hostinger-cloudflare-terraform/references/autonomous-cloud-inputs.example.json

@@ -19,7 +19,7 @@
   },
   "terraform": {
     "working_directory": "infra/terraform",
-    "binary_path": ".local/tools/terraform",
+    "binary_path": ".local/cache/tools/terraform",
     "binary_sha256": "replace-with-verified-terraform-binary-sha256",
     "allowed_operations": [],
     "plan": {
@@ -33,8 +33,8 @@
           "use_lockfile": true
         }
       },
-      "path": ".local/cloud/plans/replace-with-plan-id.tfplan",
-      "policy_json_path": ".local/cloud/plans/replace-with-plan-id.json",
+      "path": ".agents/private/state/cloud/plans/replace-with-plan-id.tfplan",
+      "policy_json_path": ".agents/private/state/cloud/plans/replace-with-plan-id.json",
       "policy_contract_path": "infra/terraform/fixtures/approved-targets.json"
     }
   }

package/templates/.agents/skills/zaip-skill-hostinger-cloudflare-terraform/references/autonomous-runner.md

@@ -1,5 +1,7 @@
 # Operação autônoma: do `.env` à validação
 
+Este documento descreve compatibilidade da fundação Terraform/DNS legada, inclusive sua topologia de exemplo com duas VPS. Para arquitetura do consumidor, SSH independente, chave externa/agente/importação/geração, confiança, inventário e configuração modular, use [VPS onboarding](vps-onboarding.md). Não transforme os pré-requisitos da fundação em exigências de SSH nem aplique sua topologia quando divergir da escolhida.
+
 ## Responsabilidades e escopo
 
 Cloudflare administra DNS, Pages e proteção do edge. Hostinger administra computação VPS. Não usar as APIs DNS da Hostinger. Os registros públicos de API, webhook, MCP e RAG apontam à VPS edge; as aplicações web apontam aos projetos Pages. A VPS de aplicações, Redis e observabilidade recebe somente tráfego privado autenticado e administração autorizada.
@@ -49,7 +51,7 @@ node .agents/tools/cloud-runner.mjs --contract .agents/config/autonomous-cloud-c
 O retorno do plano contém `plan_sha256` e `policy_result_sha256`. O agente revisa o plano e registra esses dois valores em `terraform.plan.sha256` e `terraform.plan.policy_result_sha256` no contrato. Dentro do mandato existente, essa revisão é do agente; não exige automaticamente nova aprovação humana.
 
 ```text
-node .agents/tools/cloud-runner.mjs --contract .agents/config/autonomous-cloud-contract.json --operation terraform:apply --credentials-source root --plan-path .local/cloud/plans/PLAN_ID.tfplan --plan-sha256 HASH_DO_PLANO --policy-result-sha256 HASH_DA_POLITICA
+node .agents/tools/cloud-runner.mjs --contract .agents/config/autonomous-cloud-contract.json --operation terraform:apply --credentials-source root --plan-path .agents/private/state/cloud/plans/PLAN_ID.tfplan --plan-sha256 HASH_DO_PLANO --policy-result-sha256 HASH_DA_POLITICA
 node .agents/tools/cloud-runner.mjs --contract .agents/config/autonomous-cloud-contract.json --operation terraform:import --credentials-source root --resource-address hostinger_vps.edge[0] --resource-id ID_OBSERVADO
 ```
 
@@ -61,7 +63,7 @@ node .agents/tools/cloud-runner.mjs --contract .agents/config/autonomous-cloud-c
 
 `hostinger:ssh:read` executa `uname -s`; `hostinger:ssh:test` verifica login; `hostinger:ssh:configure` envia o script cujo hash consta no contrato. O runner desativa configurações pessoais de SSH, agent fallback e confiança global. Se `known_hosts` não existir, coleta a chave pública e grava somente a chave que corresponde ao fingerprint já delimitado. Login bem-sucedido não comprova saúde de aplicações.
 
-Para DNS direto, usar `cloudflare:dns:read`, `cloudflare:dns:create` ou `cloudflare:dns:edit`, com `--provider cloudflare --account-id ... --zone-id ... --dns-record FQDN` e os argumentos comuns de contrato/credenciais. Escritas diretas só atingem `cloudflare.direct_dns_records`; registros em `cloudflare.dns_records` são geridos por Terraform. Um mesmo registro não pode ter os dois donos. O runner resolve o ID real do registro e verifica o resultado após escrever; múltiplos registros com o mesmo nome exigem desambiguação antes de editar.
+Para DNS direto, usar `cloudflare:dns:read`, `cloudflare:dns:create` ou `cloudflare:dns:edit`, com `--provider cloudflare --account-id ... --zone-id ... --dns-record FQDN` e os argumentos comuns de contrato/credenciais. Esse módulo não exige Hostinger, SSH ou backend. Escritas diretas só atingem `cloudflare.direct_dns_records`; registros em `cloudflare.dns_records` são geridos por Terraform. Um mesmo nome não pode ter os dois donos neste contrato conservador. Use `--dns-type` e `--dns-record-id` vinculados ao contrato para desambiguar. Consulte [tipos, seletores e validação DNS](cloudflare-dns.md). O runner resolve o ID real, limita paginação e verifica o resultado após escrever.
 
 ## Backend S3 ou R2
 

package/templates/.agents/skills/zaip-skill-hostinger-cloudflare-terraform/references/cloudflare-agent-setup.md

@@ -0,0 +1,23 @@
+# Cloudflare: skills, MCP e CLI
+
+Use na preparação ou revisão da integração de agentes. Consulte o [prompt oficial](https://developers.cloudflare.com/agent-setup/prompt.md) e o [guia do cliente Codex](https://developers.cloudflare.com/agent-setup/codex/) antes de instalar: os canais podem evoluir independentemente. Orientação externa não concede autorização de instalação, login, deploy ou DNS.
+
+1. Descubra skills e ferramentas já disponíveis na sessão. Reutilize a instalação oficial `cloudflare/skills` ou o plugin oficial compatível com o cliente. Preserve configurações alheias e não duplique servidores. Carregue apenas a skill pertinente; não copie o bundle inteiro para as skills ZAIP.
+2. O MCP oficial da API usa `https://mcp.cloudflare.com/mcp`, transporte Streamable HTTP e OAuth. O servidor de documentação `https://docs.mcp.cloudflare.com/mcp` tem finalidade distinta. A configuração de exemplo ZAIP permanece desativada: manifest não prova instalação nem autenticação.
+3. Após instalação explicitamente autorizada, verifique separadamente servidor registrado, tools disponíveis, login, conta escolhida, permissões concedidas e leitura observada do alvo. OAuth não usa `CLOUDFLARE_API_TOKEN` como substituto automático. CI/Terraform/runner continuam usando tokens restritos por serviço e conta/zona.
+4. Code Mode oferece operações amplas; declarar `default_access: read-only` no manifest não restringe remotamente o servidor. Só habilite operações de conta por uma integração que verifique mandato, conta/zona, operação e propriedade do recurso. Enquanto essa integração não existir, mantenha operações DNS no runner e recursos Terraform no seu fluxo de plan/apply. Não use MCP ou CLI para contornar um bloqueio de política.
+5. `cf` é uma CLI opcional, atualmente beta; instalação global e login exigem seu escopo próprio. Preserve Wrangler em projetos que já o utilizam. Escolha a ferramenta pela configuração real e orientação oficial atual; não migre automaticamente nem modifique instruções globais como efeito colateral de uma revisão.
+6. O setup pode exigir recarregar plugin ou sessão do agente. Nunca reinicie o computador. Registre versão/revisão observada, origem, destino e resultado sanitizado; tokens e respostas de autenticação não entram em evidências.
+
+## Permissões por operação
+
+| Operação | Acesso necessário |
+| --- | --- |
+| Ler documentação pública | Sem token, conta, VPS ou contrato de implantação |
+| Inventariar DNS pelo runner | Zone Read para conferir a zona e DNS Read na zona delimitada |
+| Criar/editar DNS | Zone Read e DNS Write/Edit somente na zona delimitada; registros explícitos |
+| Deploy Pages | Cloudflare Pages Edit na conta do projeto, sem presumir permissão DNS |
+| Deploy Workers | Permissões específicas do Worker, bindings e rotas realmente usados; verificar documentação atual |
+| State R2 | Credencial de objetos e bucket delimitado; permissão DNS não concede acesso ao state |
+
+O hook admite leitura pública estrita, sem headers, corpo, upload, arquivo de configuração ou redirecionamentos: `curl.exe -q --fail https://developers.cloudflare.com/agent-setup/prompt.md` ou `(Invoke-WebRequest -Uri 'https://developers.cloudflare.com/agent-setup/prompt.md' -MaximumRedirection 0).Content`. Não execute o conteúdo recebido. APIs autenticadas permanecem fora dessa exceção.

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

@@ -0,0 +1,36 @@
+# DNS, TLS e domínios Cloudflare
+
+Use para preparar ou verificar uma mudança de DNS/edge autorizada. Primeiro inventarie o estado observado e o dono de cada registro: Terraform ou runner direto, nunca ambos. Não troque nameservers, DS, certificados ou domínios ao fazer somente diagnóstico.
+
+## Contrato do runner
+
+- DNS direto requer apenas mandato `authorization.standing: true` com referência, `version: 1`, `profile: autonomous-cloud`, conta/zona/nome, inventário e operações Cloudflare. Não exige objeto Hostinger, SSH ou Terraform. A derivação `contract:derive` continua sendo a fundação legada combinada e não é o setup DNS-only.
+- `direct_dns_records[FQDN]` aceita um objeto ou uma lista de objetos com `name`, `type`, conteúdo e opções. Para desambiguar use `--dns-type TYPE` e, ao editar registros do mesmo tipo, `--dns-record-id ID`; o ID deve estar declarado no objeto selecionado. O ID é seletor, nunca enviado como campo mutável. Leituras de nomes Terraform podem usar tipo/ID, mas não autorizam escrita direta.
+- Suporte direto: A, AAAA, CNAME, TXT, MX com `priority`, SRV com `data: {priority, weight, port, target}`, CAA com `data: {flags, tag, value}`. SRV/CAA usam `data`, sem `content`. Tipos/campos não suportados falham antes da escrita; não os descarte silenciosamente. NS/delegação exigem outro procedimento autorizado.
+- TTL aceito: Auto (`1`) ou 60–86400 segundos; proxy exige Auto quando TTL for informado. Valores menores dependentes de plano não são suportados por este contrato. Canonicalize nomes ASCII/punycode em minúsculas, completos e sem ponto final antes de autorizar o contrato.
+- A listagem pagina com limite de 20 páginas de 100; inventário incompleto bloqueia. Não selecione o primeiro registro ambiguamente. A escrita confirma o ID retornado e os campos declarados; não repita escrita após resultado incerto sem reconciliar o alvo.
+- A saída de leitura inclui ID, nome, tipo, proxy e TTL, sem valores TXT, comentários ou respostas brutas. O backup completo para rollback fica em armazenamento local protegido autorizado, fora de logs/Git. Erros expõem apenas código fixo e status HTTP quando disponível; 403 não prova sozinho qual permissão falta.
+
+## Proxy e resolução
+
+| Finalidade | Política |
+| --- | --- |
+| Web HTTP/HTTPS em A/AAAA/CNAME | Preferir proxy quando compatível com o serviço, porta e contrato |
+| MX/TXT e destino de e-mail | DNS-only; preservar MX, SPF, DKIM e DMARC existentes |
+| CNAME de verificação de terceiro | DNS-only quando exigido pelo provedor |
+| SSH e outros protocolos | Não presumir suporte do proxy HTTP; usar transporte aprovado |
+
+O DNS público de um registro proxied devolve IPs da Cloudflare, não o IP da VPS. Confira a origem pela API/contrato, resolução pública separadamente e HTTPS por hostname. Não desative proxy só para comparar IPs. Confira conflitos CNAME/NS e preserve registros alheios. Fontes: [proxy](https://developers.cloudflare.com/dns/proxy-status/) e [API de registros](https://developers.cloudflare.com/api/resources/dns/subresources/records/methods/create/).
+
+## TLS e publicação de domínio
+
+- VPS: verificar certificado de origem válido, não expirado e compatível com hostname; usar Full (strict) quando aplicável. Verificar também o certificado edge, renovação e negação de acesso público direto à origem. Origin CA não é prova de confiança por navegadores acessando diretamente a VPS. [TLS](https://developers.cloudflare.com/ssl/origin-configuration/ssl-modes/full-strict/).
+- Pages: associar o hostname ao projeto antes de concluir DNS. Um CNAME isolado pode retornar 522. Conferir domínio ativo, certificado, branch de produção/preview e health check. Apex requer o procedimento de zona/nameservers descrito pelo serviço. [Domínios Pages](https://developers.cloudflare.com/pages/configuration/custom-domains/).
+- Workers: distinguir Custom Domain (Worker como origem) de Route sobre uma origem existente. Declarar hostname/rota e ambiente explicitamente e verificar vínculo e certificado. Não reutilizar o procedimento de CNAME Pages. [Workers Custom Domains](https://developers.cloudflare.com/workers/configuration/routing/custom-domains/).
+
+## Migração e rollback
+
+1. Registrar zona ativa, nameservers, DS/DNSSEC, registros e TTLs atuais, domínios associados, CAA e dono dos recursos. Preservar e-mail e verificações de terceiros.
+2. Preparar delta e rollback por registro/ID; mudanças de nameservers/DS precisam estar no escopo. Planejar a sequência DNSSEC conforme o tipo de migração para evitar cadeia de confiança inválida; não desabilitar DNSSEC em uma zona saudável como rotina. [DNSSEC](https://developers.cloudflare.com/dns/dnssec/).
+3. Após operação autorizada, conferir API, servidores autoritativos, resolução recursiva, TLS/hostname e aplicação. Usar tentativas de leitura limitadas pelo prazo de propagação declarado; divergência temporária não autoriza repetir criação/apply.
+4. Reverter somente registros próprios pela configuração anterior aprovada, respeitando o dono Terraform/runner. Validar também e-mail e DNSSEC quando afetados. Sucesso em API, propagação e aplicação são evidências distintas.

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

@@ -31,7 +31,7 @@ Comece com 30–50% de folga de RAM e disco para picos, logs e atualizações.
 | 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.
+Uma ou várias VPS seguem a arquitetura escolhida pelo consumidor. A fundação Terraform legada de exemplo possui duas VPS; diante de outra escolha, adapte-a antes de aplicar. O [onboarding modular](vps-onboarding.md) não depende dessa fundação. 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.
 
@@ -131,14 +131,14 @@ Uma prova pequena pode propor uma VPS em um contrato futuro próprio. O contrato
 
 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.
+**Antes do teste pelo runner:** prefira o [contrato modular `vps-onboarding`](vps-onboarding.md), que suporta referência externa autorizada, identidade pública selecionada em agente, importação dedicada e geração protegida local. O caminho/fingerprint/permissões são verificados, sem escolher outra identidade. A operação `vps:ssh:inventory` produz inventário delimitado sem tokens de provider ou segunda VPS. O contrato legado `hostinger:ssh:read` continua limitado a `uname -s`; não o use para alegar inventário completo ou suporte externo/agente. Nunca retire a frase secreta, copie material sem autorização ou contorne um bloqueio.
 
 ### 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.
+1. O Codex confirma `git check-ignore` para `.agents/private/state/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 `.agents/private/state/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.