@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/skills/zaip-aios/SKILL.md

@@ -1,5 +1,5 @@
 ---
-# zaip-managed generated-do-not-edit source=discovery-skill version=1.0.0 sha256=72e09e90f33f9ed2543daf8dfc09ee5b10fca74d7fa077db030b8b048301d806
+# zaip-managed generated-do-not-edit source=discovery-skill version=1.0.8 sha256=72e09e90f33f9ed2543daf8dfc09ee5b10fca74d7fa077db030b8b048301d806
 name: zaip-aios
 description: Discover and apply the repository-local ZAIP-AIOS framework.
 ---

package/templates/.agents/skills/zaip-skill-brand-governance/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: zaip-skill-brand-governance
+description: Define and govern an evidence-backed brand platform, Brandbook, archetypes, and brand identity decisions. Use for brand strategy and governance; not for product design-system implementation or marketing campaign execution.
+---
+
+# Governar a marca
+
+1. Delimite objetivo, públicos, contexto de negócio, fontes e autoridade de aprovação. Classifique cada afirmação como evidência, hipótese ou decisão; não apresente hipótese como fato.
+2. Construa ou atualize a plataforma: cultura, propósito, posicionamento, proposta de valor, promessa, diferenciais, atributos, personalidade, arquitetura de marca e pontos de contato.
+3. Quando o trabalho incluir um Brandbook, mantenha uma fonte estratégica interna e derive uma versão externa somente com conteúdo autorizado. Preserve versão, proprietário, aprovadores, confidencialidade e histórico de decisão.
+4. Para arquétipos, registre evidência, comportamento esperado, limites e implicações para linguagem e experiência. Se houver pesos, valide que o total é 100%; se não houver pesquisa, registre como hipótese de trabalho.
+5. Para diferencial semântico, registre dimensões, polos, escala, fonte, data, amostra e diferença entre identidade desejada e percebida. Não fabrique respostas, baseline, validação estatística ou brand equity.
+6. Encaminhe aplicação ordinária de Brandbook aprovado, campanhas, copy e ativos para Lúcia; scripts e playbooks sales-facing para Aaron; análise quantitativa para Gabi; impacto de receita/custo e RevOps para Robert; e produção operacional genérica para Clara. Um Brandbook aprovado é input, não motivo para assumir a aplicação.
+
+Consulte [padrões de Brandbook](references/brandbook-standards.md) ao estruturar entregáveis internos ou externos.

package/templates/.agents/skills/zaip-skill-brand-governance/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Branding Specialist"
+  short_description: "Define and govern an evidence-backed brand platform."
+  default_prompt: "Use $zaip-skill-brand-governance to define or govern an evidence-backed brand platform."

package/templates/.agents/skills/zaip-skill-brand-governance/references/brandbook-standards.md

@@ -0,0 +1,30 @@
+# Padrões de Brandbook e governança
+
+Use este roteiro quando o pedido exigir a plataforma ou o Brandbook da marca.
+
+## Fonte estratégica interna
+
+Registre os treze domínios: cultura da empresa e da marca; posicionamento e plataforma; Brandbook interno e externo; arquitetura e portfólio; modelo e diretrizes de gestão; RACI e equipe de marca; procedimentos; sistema de identidade; manuais de identidade; pontos de contato; stakeholders; métricas e avaliações; e brand equity.
+
+O Brandbook Mestre também registra controle do documento; história; mercado; público e personas; promessa e diferenciais; DNA, atributos e personalidade; tom de voz; arquitetura; identidade verbal e visual; evidências e decisões.
+
+Cada decisão material deve informar proprietário, aprovador, versão, data, evidência e classificação de confidencialidade. Conteúdo proprietário de terceiros serve como referência metodológica, nunca como conteúdo reutilizável.
+
+## Versão externa
+
+Derive a publicação externa da fonte interna. Ela pode comunicar propósito, posicionamento aprovado, promessa, diferenciais, personalidade, tom e aplicações autorizadas. Exclua pesquisa bruta, comparativos competitivos, dados pessoais, riscos, negociações, valuation, hipóteses não aprovadas e justificativas confidenciais.
+
+## Instrumentos
+
+- Diferencial semântico: use polos claros, escala explícita de -3 a +3 e zero neutro. Armazene perfil desejado e percepção observada separadamente.
+- Diferencial semântico: para cada perfil, registre versão, fonte, respondente ou amostra, data, confiança e finalidade. Mantenha os perfis intended, internal, external e competitor separados; ausência de amostra é uma limitação, não uma pontuação.
+- Arquétipos: documente papel dominante, papéis de apoio, motivação, comportamento, sombra, evidência, contraevidência e comportamentos do/don't. Pesos devem totalizar 100% somente quando forem usados.
+- Métricas: se não houver dataset ou método validável, registre a métrica como pendente; não infira reconhecimento, preferência ou valor de marca.
+
+## Operação contínua
+
+Mantenha RACI, cadência de revisão, critério de exceção, inventário de touchpoints, matriz de stakeholders e log de versões. Cada mudança de identidade deve ligar a decisão à plataforma, ao manual afetado e ao responsável pela aplicação.
+
+## Handoffs
+
+Sarah decide a estratégia e a governança da marca. Manu traduz decisões aprovadas para o design system digital; Lúcia ativa a marca em marketing; Gabi mede dados; Robert relaciona oportunidades a receita, custo e RevOps; Clara produz artefatos operacionais autorizados.

package/templates/.agents/skills/zaip-skill-dashboard-sqlite/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: zaip-skill-dashboard-sqlite
+description: Rebuild and open the isolated SQLite dashboard comparison runtime.
+---
+
+# Dashboard SQLite comparativo
+
+Use esta skill para o dashboard SQLite em `.agents/dashboard`. Ela reconstrói um snapshot descartável
+em `.local/dashboard-sqlite/read-model.sqlite`.
+
+1. Na raiz do repositório, execute `node .agents/dashboard/packages/local-runtime/scripts/rebuild-sqlite-read-model.mjs`.
+2. Para regenerar os artefatos sem depender dos globs do workspace principal, execute
+   `node .agents/dashboard/packages/local-runtime/scripts/build-sqlite-dashboard.mjs`.
+3. Verifique a paridade de all-time/intervalos, zero conhecido e todo-desconhecido/null com
+   `node .agents/dashboard/packages/local-runtime/scripts/test-sqlite-read-model.mjs`.
+4. Abra com `node .agents/dashboard/packages/local-runtime/start-dashboard.mjs` ou com
+   `.agents/dashboard/zaip-dashboard-windows.exe`.
+5. Confirme `GET /api/v2/health`: o retorno deve conter `kind: zaip-dashboard-sqlite-runtime` e
+   `storage.storage_mode: sqlite_read_model`.
+
+O banco é um read model dos registros e da configuração ZAIP. `daily_aggregates` é derivada do
+read model lifecycle diário e alimenta, via SQL, os fatos de primeiro fold de
+`operations?scope=quick` e `cost-monitor?scope=summary` (runs, tokens, custo e cobertura).
+A duração híbrida legada e os detalhes de entidades permanecem no projection/adapter compartilhado
+para preservar semântica. A API é somente leitura para que o snapshot não fique desatualizado.

package/templates/.agents/skills/zaip-skill-dashboard-sqlite/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ZAIP Dashboard SQLite"
+  short_description: "Rebuild and open the isolated SQLite dashboard comparison."
+  default_prompt: "Use $zaip-skill-dashboard-sqlite to rebuild the disposable read model and verify the isolated dashboard."

package/templates/.agents/skills/zaip-skill-executar-fila-pronta/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: zaip-skill-executar-fila-pronta
+description: Execute the full eligible ready-work snapshot using the canonical queue order.
+---
+
+# Executar fila pronta
+
+Use esta skill para uma rodada idempotente que processa sequencialmente o snapshot elegível da fila. A seleção é estrita: PRD `ready`, depois SPEC `ready` independente, depois Task-first standalone elegível em `Pronto para Executar`.
+
+1. A primeira ação da conversa agendada chama `codex_app set_thread_title` sem `threadId`, usando a hora local `America/Sao_Paulo` no formato exato `[YYYY-MM-DD-T-HH-mm] Tarefa Agendada`. Registre a falha de renomeação observada e continue para a fila; ela não bloqueia a rodada.
+2. Valide o checkout local, `zaip.enabled: true`, registros canônicos e runtime. Leia `.agents/dashboard/work-priority.json` quando existir; ausência ou conteúdo inválido equivale a nenhuma prioridade manual, nunca a uma ordem inventada.
+3. Antes de selecionar, crie atomicamente `.local/automation/ready-queue.lock.json` (diretório local não versionado) com `owner_token` aleatório, `fencing_token`, `acquired_at` e `expires_at`. O `fencing_token` é um inteiro monotônico: toda aquisição que substitui um lock expirado recebe valor maior que o último valor observado. Se existir lock válido de outra rodada, retorne sem efeito; nunca force a sobreposição. Renove o mesmo lock, com token e `owner_token` conferidos, antes de cada candidato. Antes de cada efeito (incluindo iniciar uma Execution), releia o lock e exija ambos os tokens atuais e prazo válido; se a renovação falhar ou o token não for atual, encerre a rodada sem executar mais efeitos. Libere somente ao terminar e apenas se o `owner_token` ainda corresponder; locks expirados podem ser substituídos atomicamente.
+4. Forme os candidatos nesta precedência: (a) PRDs `ready`; (b) SPECs `ready` que não descendem de PRD; (c) Tasks Task-first standalone `prepared`/`planned`, com dependências concluídas e exatamente um PreparedPlan resolvível: `prepared_plan` inline válido **ou** `plan_ref` válido, nunca ambos. A Task ainda não pode ter Execution vinculada e nunca pode ter sido iniciada ou tentada. Para cada candidata, exclua o registro sem `status: planned`, com `started_at`, `attempt_count` diferente de zero, Execution existente, estado de plano ambíguo, ou cujo próprio ID apareça em `task next` ou no conjunto materializado concorrente. Exclua também descendentes de PRD/SPEC e itens `active`, `blocked`, `failed`, `cancelled` ou terminais.
+5. Ordene cada classe por `.agents/dashboard/work-priority.json`: itens enumerados no Kanban vêm primeiro e mantêm a ordem de cima para baixo; os sem enumeração entram depois pelo fallback canônico determinístico. Congele o snapshot ordenado e processe todos os PRDs antes de SPECs, e todos os SPECs antes das Tasks; não misture classes.
+6. Execute cada unidade do snapshot, uma por vez, pelo comando explícito no menor grão (`prd execute`, `spec execute` ou `task execute`). Para uma Task-first elegível, use `task execute` para materializar sua Execution; não crie a Execution por outro atalho. Reavalie o estado antes de cada início e pule o item que deixou de ser elegível. Preserve os gates de write scope, dependências, evidências, testes e finalizador; uma seleção não é autorização para ignorar qualquer gate.
+7. Registre o resultado de cada unidade, as omissões e a ausência de candidatos, e solte o lease. Sem candidato, retorne `no_eligible_work`; com precondição ausente, conflito de lease ou estado ambíguo, falhe fechado e não altere registros.
+
+Esta skill não cria um agendamento. Ela só pode ser chamada pela automação nativa do Codex Desktop ou por um usuário com autoridade explícita para executar o trabalho selecionado.

package/templates/.agents/skills/zaip-skill-executar-fila-pronta/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "ZAIP Executar Fila Pronta"
+  short_description: "Execute o ciclo completo do snapshot elegível da fila pronta."
+  default_prompt: "Use $zaip-skill-executar-fila-pronta para executar o ciclo completo do snapshot elegível, respeitando a prioridade do Kanban e sem promover ou retomar itens inelegíveis."
+policy:
+  allow_implicit_invocation: false

package/templates/.agents/skills/zaip-skill-executar-fila-pronta/scripts/ready-queue-fence.mjs

@@ -0,0 +1,71 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+export async function acquireReadyQueueFence(lockPath, input) {
+  return withMutex(lockPath, async () => {
+    const current = await readLease(lockPath);
+    if (current !== null && current.released_at === undefined && current.expires_at > input.now)
+      return null;
+    const lease = {
+      owner_token: input.owner_token,
+      fencing_token: (current?.fencing_token ?? 0) + 1,
+      acquired_at: input.now,
+      expires_at: input.expires_at,
+    };
+    await writeLease(lockPath, lease);
+    return lease;
+  });
+}
+export async function renewReadyQueueFence(lockPath, lease, now, expiresAt) {
+  return withMutex(lockPath, async () => {
+    if (!(await assertReadyQueueFence(lockPath, lease, now))) return null;
+    const renewed = { ...lease, expires_at: expiresAt };
+    await writeLease(lockPath, renewed);
+    return renewed;
+  });
+}
+export async function assertReadyQueueFence(lockPath, lease, now) {
+  const current = await readLease(lockPath);
+  return (
+    current !== null &&
+    current.released_at === undefined &&
+    current.owner_token === lease.owner_token &&
+    current.fencing_token === lease.fencing_token &&
+    current.expires_at > now
+  );
+}
+export async function releaseReadyQueueFence(lockPath, lease, now) {
+  return withMutex(lockPath, async () => {
+    if (!(await assertReadyQueueFence(lockPath, lease, now))) return false;
+    await writeLease(lockPath, { ...lease, expires_at: now, released_at: now });
+    return true;
+  });
+}
+async function withMutex(lockPath, operation) {
+  const mutex = `${lockPath}.mutex`;
+  await mkdir(dirname(lockPath), { recursive: true });
+  try {
+    await mkdir(mutex);
+  } catch (error) {
+    if (error?.code === "EEXIST") return null;
+    throw error;
+  }
+  try {
+    return await operation();
+  } finally {
+    await rm(mutex, { recursive: true, force: true });
+  }
+}
+async function readLease(lockPath) {
+  try {
+    return JSON.parse(await readFile(lockPath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writeLease(lockPath, lease) {
+  const temporary = resolve(dirname(lockPath), `.${lease.owner_token}.ready-queue.tmp`);
+  await writeFile(temporary, `${JSON.stringify(lease)}\n`, "utf8");
+  await rename(temporary, lockPath);
+}

package/templates/.agents/skills/zaip-skill-executar-fila-pronta/scripts/ready-queue-fence.test.mjs

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import {
+  acquireReadyQueueFence,
+  assertReadyQueueFence,
+  releaseReadyQueueFence,
+  renewReadyQueueFence,
+} from "./ready-queue-fence.mjs";
+
+test("fence is exclusive, monotonic, and rejects a stale owner", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "zaip-ready-fence-"));
+  const lock = join(directory, "ready-queue.lock.json");
+  try {
+    const [first, concurrent] = await Promise.all([
+      acquireReadyQueueFence(lock, {
+        owner_token: "owner-a",
+        now: "2026-08-05T18:00:00.000Z",
+        expires_at: "2026-08-05T18:01:00.000Z",
+      }),
+      acquireReadyQueueFence(lock, {
+        owner_token: "owner-b",
+        now: "2026-08-05T18:00:00.000Z",
+        expires_at: "2026-08-05T18:01:00.000Z",
+      }),
+    ]);
+    const owner = first ?? concurrent;
+    assert.equal([first, concurrent].filter((candidate) => candidate !== null).length, 1);
+    assert.equal(owner?.fencing_token, 1);
+    const second = await acquireReadyQueueFence(lock, {
+      owner_token: "owner-b",
+      now: "2026-08-05T18:01:01.000Z",
+      expires_at: "2026-08-05T18:02:00.000Z",
+    });
+    assert.equal(second?.fencing_token, 2);
+    assert.equal(
+      await renewReadyQueueFence(
+        lock,
+        owner,
+        "2026-08-05T18:01:02.000Z",
+        "2026-08-05T18:03:00.000Z",
+      ),
+      null,
+    );
+    assert.equal(await assertReadyQueueFence(lock, owner, "2026-08-05T18:01:02.000Z"), false);
+    assert.equal(await releaseReadyQueueFence(lock, owner, "2026-08-05T18:01:02.000Z"), false);
+    assert.equal(await releaseReadyQueueFence(lock, second, "2026-08-05T18:01:03.000Z"), true);
+    const third = await acquireReadyQueueFence(lock, {
+      owner_token: "owner-c",
+      now: "2026-08-05T18:01:04.000Z",
+      expires_at: "2026-08-05T18:02:00.000Z",
+    });
+    assert.equal(third?.fencing_token, 3);
+    assert.equal(await releaseReadyQueueFence(lock, third, "2026-08-05T18:01:05.000Z"), true);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});

package/templates/.agents/skills/zaip-skill-executar-fila-pronta/scripts/scheduled-ready-queue-contract.test.mjs

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import { access, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import test from "node:test";
+
+const root = resolve(import.meta.dirname, "../..");
+const read = (path) => readFile(resolve(root, path), "utf8");
+const repositoryReadme = resolve(root, "../../README.md");
+
+test("hourly ready queue contracts the native Codex scheduler and full ordered snapshot", async () => {
+  const [installer, executor] = await Promise.all([
+    read("zaip-skill-instalar-agendamento/SKILL.md"),
+    read("zaip-skill-executar-fila-pronta/SKILL.md"),
+  ]);
+
+  assert.match(installer, /Codex Desktop/);
+  assert.match(installer, /automation_update/);
+  assert.match(installer, /codex_app list_projects/);
+  assert.match(installer, /codex_app automation_update/);
+  assert.match(installer, /\$CODEX_HOME\/automations\/\*\/automation\.toml/);
+  assert.match(installer, /somente em leitura/);
+  assert.match(
+    installer,
+    /exclusivamente pelo nome estável para resolver identidade e deduplicação/,
+  );
+  assert.match(installer, /É proibido criar, editar ou apagar TOML/);
+  assert.match(installer, /ou usá-lo como fallback/);
+  assert.match(
+    installer,
+    /Todas as visualizações e mutações da automação são exclusivamente por `codex_app automation_update`/,
+  );
+  assert.match(installer, /ZAIP-AIOS - Fila Pronta Horária/);
+  assert.match(installer, /cada hora/);
+  assert.match(installer, /checkout local/);
+  assert.match(installer, /standalone/);
+  assert.match(installer, /sem duplicar/);
+  assert.match(installer, /Nunca use o Agendador do Windows/);
+  assert.match(installer, /authorizes only canonically ready\/eligible items/);
+  assert.match(installer, /a cada hora, no minuto 0/);
+  assert.match(installer, /nova conversa/);
+  assert.match(installer, /\.agents\/dashboard\/work-priority\.json/);
+  assert.match(installer, /Ignore Automation memory and \$CODEX_HOME/);
+  assert.match(installer, /Start immediately by validating the repository and ready queue/);
+  assert.match(installer, /set_thread_title without threadId/);
+  assert.match(installer, /\[YYYY-MM-DD-T-HH-mm\] Tarefa Agendada/);
+
+  assert.match(executor, /snapshot elegível/);
+  assert.match(executor, /todos os PRDs antes de SPECs, e todos os SPECs antes das Tasks/);
+  assert.match(executor, /descendem de PRD/);
+  assert.match(executor, /`active`, `blocked`, `failed`, `cancelled` ou terminais/);
+  assert.match(executor, /\.agents\/dashboard\/work-priority\.json/);
+  assert.match(executor, /\.local\/automation\/ready-queue\.lock\.json/);
+  assert.match(executor, /owner_token/);
+  assert.match(executor, /fencing_token/);
+  assert.match(executor, /inteiro monotônico/);
+  assert.match(executor, /Antes de cada efeito/);
+  assert.match(executor, /set_thread_title/);
+  assert.match(executor, /sem `threadId`/);
+  assert.match(executor, /America\/Sao_Paulo/);
+  assert.match(executor, /falha de renomeação observada/);
+  assert.match(executor, /Task-first standalone `prepared`\/`planned`/);
+  assert.doesNotMatch(executor, /Task-first materializada/);
+  assert.match(executor, /exatamente um PreparedPlan resolvível/);
+  assert.match(executor, /`prepared_plan` inline válido \*\*ou\*\* `plan_ref` válido, nunca ambos/);
+  assert.match(executor, /não pode ter Execution vinculada/);
+  assert.match(executor, /nunca pode ter sido iniciada ou tentada/);
+  assert.match(executor, /Para cada candidata/);
+  assert.match(
+    executor,
+    /cujo próprio ID apareça em `task next` ou no conjunto materializado concorrente/,
+  );
+  assert.doesNotMatch(executor, /`task next` não vazio/);
+  assert.match(executor, /use `task execute` para materializar sua Execution/);
+
+  if (
+    await access(repositoryReadme).then(
+      () => true,
+      () => false,
+    )
+  ) {
+    const readme = await readFile(repositoryReadme, "utf8");
+    assert.match(readme, /\$zaip-skill-instalar-agendamento/);
+    assert.match(readme, /rodada horária/);
+    assert.match(readme, /Pronto para Executar/);
+    assert.match(readme, /Dashboard > Trabalho \(Kanban\) > Pronto para Executar/);
+    assert.match(readme, /máquina ligada, do Codex Desktop em execução/);
+  }
+});
+
+test("fencing lease rejects stale effects after renewal or ownership failure", () => {
+  let lock = { owner_token: "owner-a", fencing_token: 7, expires_at: 20 };
+  const renew = (owner, now, expiry) => {
+    if (lock.owner_token !== owner || now >= lock.expires_at) return null;
+    lock = { ...lock, expires_at: expiry };
+    return lock;
+  };
+  const effect = (owner, fence, now) => {
+    assert.equal(lock.owner_token, owner, "owner token must still match");
+    assert.equal(lock.fencing_token, fence, "fencing token must still be current");
+    assert.ok(now < lock.expires_at, "lease must be valid before an effect");
+    return "executed";
+  };
+
+  assert.equal(effect("owner-a", 7, 10), "executed");
+  assert.equal(renew("owner-a", 10, 30)?.fencing_token, 7);
+  lock = { owner_token: "owner-b", fencing_token: 8, expires_at: 40 };
+  assert.throws(() => effect("owner-a", 7, 11), /owner token/);
+  assert.equal(renew("owner-a", 11, 50), null);
+  assert.throws(() => effect("owner-b", 7, 12), /fencing token/);
+  assert.equal(effect("owner-b", 8, 12), "executed");
+});

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

@@ -7,7 +7,7 @@ description: Execute prepared ZAIP work explicitly, materialize its DAG, and clo
 
 Use esta skill somente quando o usuário pedir execução. `prepare` não autoriza mutação nem promoção para `ready`; quando a execução foi pedida explicitamente, prepare o PRD/SPEC ainda em `draft`, se necessário, e então execute sem exigir outra confirmação intermediária.
 
-1. Carregue o PreparedPlan e valide hash, origem, Requirements/AC, DAG, write scopes e estado atual. Ao construir ou diagnosticar o plano externo, leia [o contrato compacto](references/prepared-plan.md).
+1. Carregue o PreparedPlan e valide hash, origem, Requirements/AC, DAG, write scopes e estado atual. Antes de selecionar executor, carregue as Rules aplicáveis; para decisão comercial, use `$RULE-SPECIALIST-ROUTING` como fonte única da matriz de roteamento. Ao construir ou diagnosticar o plano externo, leia [o contrato compacto](references/prepared-plan.md).
 2. Materialize idempotentemente Change, Tasks e Execution antes da primeira alteração do produto.
 3. A partir da tentativa explícita de `execute`, classifique uso como `execution`; inicie Execution, Changes, Tasks elegíveis e Runs com atribuição ao nível de entrada (`task`, `spec` ou `prd`). Ausência de diff não retroage a fase: registre `changed_files` vazio e o resultado real.
 4. Execute a ordem topológica. Paralelize apenas Tasks independentes cujos arquivos, módulos, migrations, ambientes e recursos não conflitem.
@@ -18,7 +18,7 @@ Use esta skill somente quando o usuário pedir execução. `prepare` não autori
 9. Em cada `run usage`, leia `budget.context_refresh_required` e `budget.checkpoint_required`. O runtime grava o checkpoint sanitizado em `.local/checkpoints/`; quando sinalizado, reconstrua contexto somente de IDs ativos, diff e findings, descarte outputs brutos antigos e continue apenas com autoridade.
 10. Em falha operacional, use retry limitado; em falha lógica, crie repair/rework explícito. Nunca esconda uma tentativa.
 11. Cada tentativa usa uma Run raiz do `zaip-agent-orchestrator`; subagentes e fases materialmente distintas usam Sub-Runs relacionadas por `parent_run_id`. Cada Run/Sub-Run fixa agente, modelo e effort; retry técnico preserva a configuração e qualquer mudança deliberada abre outra chamada de agente.
-12. Interaction read-only sem descendentes termina após a resposta, sem executor/finalizador. Para interaction com descendente delegado e para delivery, depois que todos os Sub-Runs de trabalho terminarem invoque `zaip-agent-finalizer` como último filho com propósito `finalization`. Não inicie novos filhos depois dele; auto-settlement nunca fecha interaction com descendente ativo. A CLI aplica seu resultado restrito; ausência, interrupção ou falha deixa a Execution inconclusiva como `blocked`.
+12. Interaction read-only sem descendentes termina após a resposta, sem executor/finalizador. Para interaction com descendente delegado e para delivery, depois que todos os Sub-Runs de trabalho terminarem invoque `zaip-agent-finalizer` como último filho com propósito `finalization`. Não inicie novos filhos depois dele; auto-settlement nunca fecha interaction com descendente ativo. Isso também vale para `cancelled`: o orquestrador aplica a decisão Gui pela CLI; comandos diretos Task/SPEC/PRD nunca terminalizam. Ausência, interrupção ou falha do Gui deixa a Execution inconclusiva como `blocked`.
 13. SPEC/PRD permanece `active` entre Runs filhas e só entra em verificação após todas as Tasks; a Run filha não entrega nem bloqueia automaticamente o pai.
 14. Resolva execução no menor grão explicitado: Task executa um nó elegível, SPEC executa sua DAG interna e PRD executa todas as SPECs selecionadas. Nunca amplie Task para SPEC/PRD por inferência.
 15. “Conclua a execução” ou “finalize a implementação” em macro ativo continua Tasks e gates até resultado verdadeiro; não força `deliver`. “Desenvolva/melhore/aprimore” interrompe execução implícita, registra diagnóstico e cria plano/rework antes de nova promoção.

package/templates/.agents/skills/zaip-skill-frontend-launcher/references/launcher-contract.md

@@ -2,7 +2,9 @@
 
 ## Estrutura
 
-- `<surface>/launcher.exe`: artefato de duplo clique.
+- `<surface>/zaip-dashboard-windows.exe`: artefato Windows de duplo clique.
+- `<surface>/zaip-dashboard-linux.sh`: launcher Linux executável.
+- `<surface>/zaip-dashboard-mac.command`: launcher macOS executável.
 - `<surface>/packages/windows-launcher/`: fonte C# e build PowerShell.
 - `<surface>/packages/local-runtime/`: servidor loopback, sessão, lock e testes.
 - `<surface>/apps/frontend/dist/`: build estático servido; ajuste o path à superfície real.

package/templates/.agents/skills/zaip-skill-general-operations/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: zaip-skill-general-operations
+description: Deliver bounded operational artifacts when no mandatory specialist scope applies. Use for documents, presentations, spreadsheets, process artifacts, and comparative research; do not use for regulated governance work or external acts.
+---
+
+# Executar operações gerais
+
+1. Delimite o resultado, público, fontes, formato, write scope e critério de aceitação; trate fatos ausentes como pendências, nunca como dados inferidos.
+2. Se houver capability ou escopo obrigatório de produto, design, marketing, dados, segurança, cloud, frontend, backend, website ou governança, devolva ao orquestrador para a rota especialista.
+3. Produza o artefato delimitado e uma verificação proporcional. Para identidade visual existente, siga o contrato da Manu; para conteúdo de marketing, devolva a rota para Lúcia.
+4. Pesquisa comparativa usa apenas fontes autorizadas e registra critérios, evidência e incertezas. Não contrate, envie dados, assine, publique ou execute ato externo.
+5. Quando faltar autoridade humana, entregue a minuta, checklist, lacunas e a ação humana exata; a entrega não fica sem resultado por falta dessa autoridade.

package/templates/.agents/skills/zaip-skill-general-operations/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ZAIP General Operations"
+  short_description: "Deliver bounded operational artifacts outside specialist scopes."
+  default_prompt: "Use $zaip-skill-general-operations to deliver a bounded document, presentation, spreadsheet, process artifact, or comparative research result."

package/templates/.agents/skills/zaip-skill-github-deploy/SKILL.md

@@ -5,16 +5,18 @@ description: Use only when the user explicitly asks in the current turn to deplo
 
 # Deploy and repair GitHub publication
 
+The exact command “faça deploy” authorizes publication of everything versionable in the selected worktree, including tracked and untracked files, after the safety gates below. It does not authorize provider deployment.
+
 Treat deploy as Git-only publication. An explicit current-turn request to `deploy`, `push`, `publicar`, `publicação` or GitHub publication selects this skill; it authorizes only the bounded Git publication described below, never a provider deployment or automatic publication.
 
 ## Authorization
 
 - Require an explicit deploy, push, publicar, publicação, GitHub publication, or failed-deploy repair request in the current turn.
-- The request authorizes the initial publication, bounded reconciliation needed to publish the selected branch, functional commits for the evidenced intended pending scope, and up to five repair cycles needed to make required local and remote GitHub checks pass.
+- The request authorizes the initial publication, reconciliation needed to publish the selected branch, commits covering all versionable pending changes in the selected worktree, and up to five repair cycles needed to make required local and remote GitHub checks pass.
 - Limit repairs to the intended repository state and the evidenced failure. Do not add unrelated features or broaden product scope.
 - Never force push, rewrite history, replace remotes, change credentials or Git/SSH configuration, bypass checks, or deploy to another service.
-- Do not create lifecycle artifacts for an explicit Git-only publication request. The deploy authorization may stage and commit only the evidenced intended pending scope with explicit pathspecs before publication; it never authorizes unrelated product work.
-- Map a functional group to PRD/SPEC/Task only when evidence exists; otherwise use `[CODEX] <functional title>` without `ZAIP-Task`. Omit nonexistent lineage blocks and trailers. Deploy authorization never permits `git add -A`, broad staging, force, destructive reset, squash, or publication outside the current explicit request.
+- Do not create lifecycle artifacts for an explicit Git-only publication request. The deploy authorization permits staging the complete selected worktree with `git add -A` after secret, size, and ignore checks; it never authorizes changes outside that worktree.
+- Map a functional group to PRD/SPEC/Task only when evidence exists; otherwise use `[CODEX] <functional title>` without `ZAIP-Task`. Omit nonexistent lineage blocks and trailers. Broad staging is authorized only by the exact current-turn deploy request; force, destructive reset, history rewrite, and credential changes remain prohibited.
 
 ## Mandatory authorization record
 
@@ -32,8 +34,8 @@ The conversation and terminal deploy report are the authority record for Git-onl
 ## Multiple worktrees and divergent history
 
 1. Run `git worktree list --porcelain` and inspect `git status --porcelain` in every existing worktree before staging.
-2. Select exactly one publishing worktree. A clean worktree on another branch or a detached verification worktree does not join the deploy. Preserve a stable dirty worktree and partition only its evidenced intended scope; exclude its alien paths unless the user explicitly includes them.
-3. Stop when another process or agent is actively mutating a shared branch, index, canonical source or generated projection, or when scope is ambiguous.
+2. Select exactly one publishing worktree. A clean worktree on another branch or a detached verification worktree does not join the deploy. The selected worktree is the complete publication scope.
+3. Report concurrent activity, but do not block solely because the selected worktree is dirty or contains mixed changes; the explicit “faça deploy” authorization includes those changes. Stop only for an unresolved index conflict, secret/oversize file, authentication failure, or destructive/rewrite requirement.
 4. Prunable or missing worktrees are reported but never pruned automatically. Dirty detached or temporary worktrees are never deleted, reset, stashed or copied into the publishing worktree implicitly.
 5. Fetch once and compute ahead/behind for the publishing branch. If it is behind or diverged, reconcile only the selected branch under this deploy authorization.
 6. Before reconciliation, create a recoverable branch reference and preserve tracked plus untracked changes in a named stash. Verify both references before proceeding. Use `rebase` unless the user explicitly selected `merge`.
@@ -43,7 +45,7 @@ The conversation and terminal deploy report are the authority record for Git-onl
 ## Repair-loop integrity
 
 - A publication cycle is: run deploy preflight, inventory the intended pending diff, synchronize, create any required functional commits with explicit pathspecs, push, and verify the remote hash. When no intended pending diff exists, publish already-formed commits. Run only gates required or evidenced by repository Rules, the active Change, or failed remote CI.
-- First prove each functional group and its pathspecs from the intended pending diff; stage only that group with explicit paths, commit it, then continue with the next group. A stable mixed worktree is partitioned and preserved; only a moving worktree, ambiguous scope, or unresolved conflict is a terminal blocker.
+- Inventory the complete pending diff, run the safety gates, then stage the selected worktree with `git add -A` and commit it. Do not require functional partitioning for this explicit broad-deploy mode.
 - Run each diagnostic, gate, fetch, stage, commit, push, and hash verification at most once per cycle.
 - Start a new cycle only after a repository change or new remote evidence. Never repeat an unchanged failing command hoping for a different result.
 - Continue until all required checks pass or a terminal blocker occurs. Stop after five repair cycles, or when the same root cause remains after two repairs.
@@ -69,7 +71,7 @@ Run preflight once at the start of the authorized deployment. On failure, stop.
    - Turbo cache hits are valid only when the active work did not originate from a failed remote CI gate.
    - When repairing failed CI, reproduce the exact failed gate once per repair cycle with Turbo cache bypassed when applicable.
 4. If a local gate fails, capture the exact failing command and error, make the smallest authorized repair, update lifecycle evidence, and start the next cycle without asking for another deploy authorization.
-5. After all required local gates pass, partition only the evidenced intended pending diff with explicit pathspecs. If tracked or untracked changes remain outside that scope, stop and identify the Task that must own them; never stage or combine alien changes during deploy.
+5. After all required local gates pass, stage the complete selected worktree with `git add -A`. If a file is secret, oversized, ignored by policy, or outside the selected worktree, exclude it and report the reason; otherwise include it.
 
 ## Synchronize and publish each cycle
 

package/templates/.agents/skills/zaip-skill-github-deploy/agents/openai.yaml

@@ -1,6 +1,6 @@
 interface:
   display_name: "ZAIP GitHub Deploy"
-  short_description: "Publicação GitHub explícita, Git-only e verificável"
-  default_prompt: "Use $zaip-skill-github-deploy somente para um pedido explícito neste turno de deploy, push, publicar ou publicação GitHub; registre a autorização, inventarie todos os worktrees, reconcilie com segurança apenas o worktree selecionado e publique somente o escopo evidenciado via SSH da pasta."
+  short_description: "Publicacao GitHub explicita, Git-only e verificavel"
+  default_prompt: "Use $zaip-skill-github-deploy para pedidos explicitos de deploy, push, publicar ou publicacao GitHub; quando o usuario disser 'faca deploy', trate o worktree selecionado inteiro como escopo autorizado, incluindo arquivos novos, apos os gates de segredos, tamanho, conflitos e SSH; publique via SSH da pasta sem force push nem reescrita de historico."
 policy:
   allow_implicit_invocation: true

package/templates/.agents/skills/zaip-skill-github-deploy/scripts/github-deploy-contract.test.mjs

@@ -12,22 +12,12 @@ test("explicit Git publication verbs select the guarded deploy skill", async ()
     readFile(resolve(skillRoot, "agents", "openai.yaml"), "utf8"),
     readFile(resolve(root, "rules", "core.md"), "utf8"),
   ]);
-
-  assert.match(
-    skill,
-    /explicit current-turn request to `deploy`, `push`, `publicar`, `publicação`/,
-  );
+  assert.match(skill, /explicit current-turn request to `deploy`, `push`, `publicar`/);
   assert.match(skill, /never grants publication automatically/);
   assert.doesNotMatch(skill, /standing automatic deployment|activate it automatically/);
   assert.match(openai, /\$zaip-skill-github-deploy/);
-  assert.match(
-    openai,
-    /pedido explícito neste turno de deploy, push, publicar ou publicação GitHub/,
-  );
-  assert.match(
-    core,
-    /Pedido explícito no turno de `deploy\|push\|publicar\|publicação GitHub` seleciona `\$zaip-skill-github-deploy`/,
-  );
+  assert.match(openai, /fa.a deploy/);
+  assert.match(core, /deploy.*seleciona/);
 });
 
 test("deploy guidance preserves the canonical Task subject and Git-only boundary", async () => {
@@ -35,46 +25,29 @@ test("deploy guidance preserves the canonical Task subject and Git-only boundary
     readFile(resolve(skillRoot, "SKILL.md"), "utf8"),
     readFile(resolve(root, "rules", "workflow.md"), "utf8"),
   ]);
-  const subject = "[CODEX|CLAUDE] [P:XXXX] [S:XXXX] [T:XXXX] <Task title>";
-
-  assert.ok(skill.includes(subject));
+  assert.ok(skill.includes("[CODEX|CLAUDE] [P:XXXX] [S:XXXX] [T:XXXX] <Task title>"));
   assert.match(skill, /exclusively `CODEX` or `CLAUDE`; `AUTO` is not part/);
-  assert.match(skill, /P\/S\/T blocks are emitted only when their evidence exists/);
-  assert.match(skill, /\[Task-first:XXXX\]/);
   assert.match(skill, /Git-only publication/);
-  assert.match(workflow, /assunto é ≤96 e só o título reduz por palavra/);
   assert.match(workflow, /formar commits funcionais apenas do diff pretendido\/evidenciado/);
-  assert.doesNotMatch(workflow, /deploy\/push simples publica somente commits formados/);
 });
 
-test("every explicit deploy authorizes bounded reconciliation and functional commits with pathspecs", async () => {
+test("faça deploy authorizes the complete selected worktree with safety gates", async () => {
   const skill = await readFile(resolve(skillRoot, "SKILL.md"), "utf8");
-
-  assert.match(skill, /bounded reconciliation needed to publish the selected branch/);
-  assert.match(skill, /functional commits for the evidenced intended pending scope/);
-  assert.match(skill, /Use `rebase` unless the user explicitly selected `merge`/);
-  assert.match(skill, /explicit pathspecs/);
-  assert.match(skill, /without `ZAIP-Task`/);
-  assert.match(skill, /never permits `git add -A`/);
-  assert.match(skill, /stable mixed worktree is partitioned and preserved/);
-  assert.match(
-    skill,
-    /moving worktree, ambiguous scope, or unresolved conflict is a terminal blocker/,
-  );
+  assert.match(skill, /commits covering all versionable pending changes/);
+  assert.match(skill, /`git add -A`/);
+  assert.match(skill, /selected worktree is the complete publication scope/);
+  assert.match(skill, /Stop only for an unresolved index conflict/);
 });
 
-test("deploy permission and multi-worktree reconciliation are explicit and recoverable", async () => {
+test("deploy permission and reconciliation remain explicit and recoverable", async () => {
   const [skill, openai] = await Promise.all([
     readFile(resolve(skillRoot, "SKILL.md"), "utf8"),
     readFile(resolve(skillRoot, "agents", "openai.yaml"), "utf8"),
   ]);
-
   assert.match(skill, /Mandatory authorization record/);
   assert.match(skill, /repository, remote, branch and selected worktree/);
-  assert.match(skill, /`rebase` by default, or user-selected `merge`/);
   assert.match(skill, /recoverable branch reference/);
   assert.match(skill, /preserve tracked plus untracked changes in a named stash/);
   assert.match(skill, /Restore with `git stash apply`/);
-  assert.match(skill, /Prunable or missing worktrees are reported but never pruned automatically/);
-  assert.match(openai, /registre a autorização, inventarie todos os worktrees/);
+  assert.match(openai, /worktree selecionado inteiro como escopo autorizado/);
 });

package/templates/.agents/skills/zaip-skill-governance-compliance/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: zaip-skill-governance-compliance
+description: Prepare non-binding internal governance and compliance artifacts for HR, legal operations, policy, privacy, vendors, and risk. Use for bounded internal work; do not give legal advice or execute external authority.
+---
+
+# Preparar governança e conformidade
+
+1. Delimite jurisdição, destinatário, fontes autorizadas, dados pessoais, prazo e autoridade necessária. Declare toda informação ausente ou incerta.
+2. Produza a minuta, checklist, matriz de risco, registro de decisão ou pacote de aprovação solicitado. Diferencie requisito fornecido, referência e hipótese.
+3. Não ofereça parecer jurídico vinculante, representação, assinatura, protocolo externo, contratação, decisão de pessoas ou aprovação regulatória.
+4. Para cada fronteira de autoridade, prepare a versão revisável, os riscos, pendências e a ação humana exata. Escale somente a decisão ou ato que exige autoridade; não interrompa a preparação do restante.
+5. Registre decisões consequenciais e evidência proporcional na Change/Execution, preservando confidencialidade e escopo declarado.

package/templates/.agents/skills/zaip-skill-governance-compliance/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ZAIP Governance and Compliance"
+  short_description: "Prepare internal governance and compliance artifacts."
+  default_prompt: "Use $zaip-skill-governance-compliance to prepare a bounded internal HR, legal-operations, policy, privacy, vendor, or risk artifact."

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

@@ -0,0 +1,15 @@
+---
+name: zaip-skill-growth-strategy-revops
+description: Guide data-driven growth strategy, RevOps decisions, experiments, and financial-impact recommendations. Use for cross-funnel growth or operating decisions; not for raw data analysis, campaign production, or external commercial action.
+---
+
+# Orientar Growth e RevOps
+
+1. Delimite a decisão de negócio, período, segmentos, funil, métricas, restrições e impacto financeiro esperado. Separe fatos observados, cálculo determinístico, hipótese e recomendação.
+2. Examine a ponta a ponta do funil e dos handoffs de RevOps: aquisição, qualificação, conversão, receita, retenção, expansão, custos e capacidade. Não declare causalidade sem desenho ou evidência adequados.
+3. Proponha testes com hipótese, população, métrica primária, guardrails, duração, critério de decisão, risco e responsável. Não execute campanhas, alterações comerciais externas ou experimentos sem a autorização e o escopo correspondentes.
+4. Priorize oportunidades por impacto potencial, confiança, esforço, dependências e reversibilidade. Para recomendações financeiras, explicite fórmula, premissas, sensibilidade e lacunas; não prometa receita nem economia.
+5. Em conselho ou planejamento de negócio, priorize portfólio, modelo de negócio, opções e handoffs de execução. Solicite análise reprodutível de Gabi quando houver dataset, cálculo, qualidade de dados ou significância. Encaminhe plataforma de marca à Sarah, campanha/copy a Lúcia e playbook/processo sales-facing a Aaron.
+6. Produza uma recomendação consultiva: decisão, evidência, incerteza, opções, impacto esperado, próximo experimento e dono da próxima ação. Não produza campanha, Brandbook ou playbook comercial como substituto da recomendação.
+
+Consulte o [framework de decisão](references/growth-revops-framework.md) para planejar diagnóstico ou experimento.

package/templates/.agents/skills/zaip-skill-growth-strategy-revops/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Growth Strategist"
+  short_description: "Guide data-driven growth and RevOps decisions."
+  default_prompt: "Use $zaip-skill-growth-strategy-revops to analyze growth or RevOps decisions with evidence."