@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-telemetry-lib.test.mjs

@@ -11,8 +11,9 @@ import {
   duplicateUsageImpact,
   exactCompletedSegment,
   exactRemeasurementSegment,
-  jsonLines,
   isExactDuplicateUsageGroup,
+  jsonLines,
+  loadSegments,
   pricingFor,
   recordSequence,
   recordType,
@@ -27,7 +28,28 @@ const roots = [];
 after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
 
 test("sums duplicate assignment impact without inventing duration", () => {
-  assert.deepEqual(duplicateUsageImpact([{ usage: { tokens: { input: 2, output: 3, total: 5 }, cost: { usd: 1, brl: 5 }, source_started_at: "2026-01-01T00:00:00Z", source_finished_at: "2026-01-01T00:00:01Z" } }]), { assignments: 1, input_tokens: 2, output_tokens: 3, total_tokens: 5, cost_usd: 1, cost_brl: 5, duration_ms: 1000, duration_assignments: 1 });
+  assert.deepEqual(
+    duplicateUsageImpact([
+      {
+        usage: {
+          tokens: { input: 2, output: 3, total: 5 },
+          cost: { usd: 1, brl: 5 },
+          source_started_at: "2026-01-01T00:00:00Z",
+          source_finished_at: "2026-01-01T00:00:01Z",
+        },
+      },
+    ]),
+    {
+      assignments: 1,
+      input_tokens: 2,
+      output_tokens: 3,
+      total_tokens: 5,
+      cost_usd: 1,
+      cost_brl: 5,
+      duration_ms: 1000,
+      duration_assignments: 1,
+    },
+  );
 });
 
 test("never supersedes usage recorded after run.finished", () => {
@@ -188,6 +210,106 @@ test("selects only one completed local segment for an exact Run turn", () => {
   );
 });
 
+test("matches an observed internal Codex subturn to its enclosing local interval", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-reconcile-internal-turn-"));
+  roots.push(root);
+  const sessionFile = join(root, "internal-subturn.jsonl");
+  await writeFile(
+    sessionFile,
+    [
+      {
+        timestamp: "2026-08-12T04:30:25.797Z",
+        type: "session_meta",
+        payload: { id: "session-1", cwd: root },
+      },
+      {
+        timestamp: "2026-08-12T04:30:26.435Z",
+        type: "event_msg",
+        payload: { type: "task_started", turn_id: "outer-turn" },
+      },
+      {
+        timestamp: "2026-08-12T04:31:00.000Z",
+        type: "response_item",
+        payload: {
+          type: "reasoning",
+          internal_chat_message_metadata_passthrough: { turn_id: "internal-subturn" },
+        },
+      },
+      {
+        timestamp: "2026-08-12T04:32:00.000Z",
+        type: "event_msg",
+        payload: {
+          type: "token_count",
+          info: {
+            last_token_usage: {
+              input_tokens: 10,
+              cached_input_tokens: 0,
+              output_tokens: 2,
+              reasoning_output_tokens: 0,
+              total_tokens: 12,
+            },
+          },
+        },
+      },
+      {
+        timestamp: "2026-08-12T04:33:00.000Z",
+        type: "event_msg",
+        payload: { type: "task_complete", turn_id: "outer-turn" },
+      },
+      {
+        timestamp: "2026-08-12T04:35:46.804Z",
+        type: "event_msg",
+        payload: { type: "task_started", turn_id: "enclosing-turn" },
+      },
+      {
+        timestamp: "2026-08-12T04:36:00.000Z",
+        type: "response_item",
+        payload: {
+          type: "reasoning",
+          internal_chat_message_metadata_passthrough: { turn_id: "internal-subturn" },
+        },
+      },
+      {
+        timestamp: "2026-08-12T04:37:00.000Z",
+        type: "event_msg",
+        payload: {
+          type: "token_count",
+          info: {
+            last_token_usage: {
+              input_tokens: 20,
+              cached_input_tokens: 0,
+              output_tokens: 4,
+              reasoning_output_tokens: 0,
+              total_tokens: 24,
+            },
+          },
+        },
+      },
+      {
+        timestamp: "2026-08-12T04:39:10.716Z",
+        type: "event_msg",
+        payload: { type: "turn_aborted", turn_id: "enclosing-turn", completed_at: 1786509550 },
+      },
+    ]
+      .map((record) => JSON.stringify(record))
+      .join("\n") + "\n",
+  );
+
+  const [outerSegment, segment] = await loadSegments(root, [sessionFile]);
+  assert.deepEqual(outerSegment.internal_turn_ids, ["internal-subturn"]);
+  assert.deepEqual(segment.internal_turn_ids, ["internal-subturn"]);
+  assert.equal(outerSegment.finished_at, "2026-08-12T04:33:00.000Z");
+  assert.equal(segment.started_at, "2026-08-12T04:35:46.804Z");
+  assert.equal(segment.finished_at, "2026-08-12T04:39:10.716Z");
+  assert.deepEqual(
+    exactCompletedSegment(
+      { client_turn_id: "internal-subturn", occurred_at: "2026-08-12T04:39:07.934Z" },
+      [outerSegment, segment],
+    ),
+    { segment, ambiguous: false },
+  );
+});
+
 test("remeasurement falls back only to the exact persisted source segment key", () => {
   const target = {
     key: "c:/users/test/.codex/sessions/2026/07/25/child.jsonl#1",
@@ -318,11 +440,10 @@ test("detects only exact duplicate segment assignments across Runs", () => {
   const groups = duplicateUsageAssignments([duplicate, legitimateDelta, first]);
 
   assert.equal(groups.length, 1);
-  assert.deepEqual(groups[0].map(({ run: item }) => item.started.run_id), [
-    "RUN-FIRST",
-    "RUN-DUPLICATE",
-    "RUN-DELTA",
-  ]);
+  assert.deepEqual(
+    groups[0].map(({ run: item }) => item.started.run_id),
+    ["RUN-FIRST", "RUN-DUPLICATE", "RUN-DELTA"],
+  );
   assert.equal(groups[0][0].base_segment_key, "sessions/2026/07/17/session.jsonl#1");
 });
 
@@ -350,7 +471,15 @@ test("keeps duplicate reconciliation unavailable and protected from backfill", (
 test("prefers later current-context assignment over earlier legacy assignment", () => {
   const run = (id, occurred_at, client_turn_id, classification_source, total) => ({
     started: { run_id: id, occurred_at, client_turn_id },
-    usage: [{ event_id: `${id}:usage`, source_segment_key: "sessions/x.jsonl#1", supersedes_event_id: null, classification_source, tokens: { input: total - 1, output: 1, total } }],
+    usage: [
+      {
+        event_id: `${id}:usage`,
+        source_segment_key: "sessions/x.jsonl#1",
+        supersedes_event_id: null,
+        classification_source,
+        tokens: { input: total - 1, output: 1, total },
+      },
+    ],
   });
   const [group] = duplicateUsageAssignments([
     run("XCHW", "2026-07-01T00:00:00.000Z", "legacy-turn", "legacy_inferred", 9_278_701),
@@ -363,12 +492,14 @@ test("prefers later current-context assignment over earlier legacy assignment",
 test("keeps canonical aliases in review instead of making them apply candidates", () => {
   const run = (id, source_segment_key) => ({
     started: { run_id: id, occurred_at: "2026-07-01T00:00:00.000Z" },
-    usage: [{
-      event_id: `${id}:usage`,
-      source_segment_key,
-      supersedes_event_id: null,
-      tokens: { input: 1, output: 1, total: 2 },
-    }],
+    usage: [
+      {
+        event_id: `${id}:usage`,
+        source_segment_key,
+        supersedes_event_id: null,
+        tokens: { input: 1, output: 1, total: 2 },
+      },
+    ],
   });
   const [aliasGroup] = duplicateUsageAssignments([
     run("RUN-A", "sessions/x.jsonl#1@RUN-A"),

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-telemetry-remeasurement.mjs

@@ -172,18 +172,26 @@ export async function appendRetrospectiveUsage(file, expectedRecords, event) {
     const beforeFinish = persisted.slice(0, finishIndex);
     const finish = persisted[finishIndex];
     const historicalCorrections = persisted.slice(finishIndex + 1);
-    const updated = [...beforeFinish, ...historicalCorrections, event, finish].map((record, index) =>
-      withSequence(record, index + 1),
+    const updated = [...beforeFinish, ...historicalCorrections, event, finish].map(
+      (record, index) => withSequence(record, index + 1),
     );
     const temporary = `${file}.remeasure.tmp`;
-    await writeFile(temporary, `${updated.map((record) => JSON.stringify(record)).join("\n")}\n`, "utf8");
+    await writeFile(
+      temporary,
+      `${updated.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
     await rename(temporary, file);
   } finally {
     await rm(lockPath, { force: true });
   }
 }
 
-export function assertRetrospectiveAppend(records, event, { allowPostTerminalCorrections = false } = {}) {
+export function assertRetrospectiveAppend(
+  records,
+  event,
+  { allowPostTerminalCorrections = false } = {},
+) {
   const finishIndex = records.findIndex((record) => recordType(record) === "run.finished");
   const finished = records[finishIndex];
   const target = records.find(
@@ -193,11 +201,13 @@ export function assertRetrospectiveAppend(records, event, { allowPostTerminalCor
     recordType(finished) !== "run.finished" ||
     (!allowPostTerminalCorrections && finishIndex !== records.length - 1) ||
     (allowPostTerminalCorrections &&
-      records.slice(finishIndex + 1).some(
-        (record) =>
-          usageView(record)?.activity_kind !== "retrospective_local_remeasurement" ||
-          usageView(record)?.retrospective_correction !== true,
-      )) ||
+      records
+        .slice(finishIndex + 1)
+        .some(
+          (record) =>
+            usageView(record)?.activity_kind !== "retrospective_local_remeasurement" ||
+            usageView(record)?.retrospective_correction !== true,
+        )) ||
     event.type !== "usage.recorded" ||
     event.retrospective_correction !== true ||
     event.activity_kind !== "retrospective_local_remeasurement" ||

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-telemetry-remeasurement.test.mjs

@@ -3,6 +3,7 @@ import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { after, test } from "node:test";
+import { planExplicitTurnRecovery } from "./reconcile-telemetry-explicit-recovery.mjs";
 import { jsonLines, usageStatus, usageView } from "./reconcile-telemetry-lib.mjs";
 import {
   appendRetrospectiveUsage,
@@ -36,6 +37,58 @@ test("selects completed native Runs for default timing-only backfill", () => {
   assert.deepEqual([...selected], ["RUN-NATIVE"]);
 });
 
+test("explicit recovery requires exact session identity, unused turns, model/effort, and SPEC text", () => {
+  const run = {
+    started: {
+      run_id: "RUN-EXPLICIT",
+      client_thread_id: "/root/agent",
+      model: "gpt-test",
+      reasoning_effort: "medium",
+    },
+    records: [
+      { type: "run.started" },
+      { type: "usage.recorded", event_id: "RUN-EXPLICIT:old", source_segment_key: "old" },
+      { type: "run.finished" },
+    ],
+    usage: [{ event_id: "RUN-EXPLICIT:old", source_segment_key: "old", tokens: { total: 1 } }],
+  };
+  const segment = {
+    key: "session#5",
+    turn_id: "turn-r7qk",
+    internal_turn_ids: ["turn-r7qk"],
+    session_agent_path: "/root/agent",
+    model: "gpt-test",
+    effort: "medium",
+    started_at: "2026-08-22T22:56:58.553Z",
+    finished_at: "2026-08-22T23:05:26.121Z",
+    raw: "SPEC-R7QK observed",
+    usage: [
+      {
+        input_tokens: 8,
+        cached_input_tokens: 3,
+        output_tokens: 2,
+        reasoning_output_tokens: 1,
+        total_tokens: 10,
+      },
+    ],
+  };
+  const plan = planExplicitTurnRecovery({
+    run,
+    segments: [segment],
+    mappings: [{ spec_id: "SPEC-R7QK", turn_id: "turn-r7qk", total: 10, usd: 1, brl: 5 }],
+  });
+  assert.equal(plan.eligible, true);
+  assert.equal(plan.turns[0].tokens.total, 10);
+  assert.equal(
+    planExplicitTurnRecovery({
+      run,
+      segments: [{ ...segment, session_agent_path: "/root/root", key: "old" }],
+      mappings: [{ spec_id: "SPEC-R7QK", turn_id: "turn-r7qk", total: 10, usd: 1, brl: 5 }],
+    }).eligible,
+    false,
+  );
+});
+
 test("inserts a correction before the terminal event under an exclusive lock", async () => {
   const root = await mkdtemp(join(tmpdir(), "zaip-remeasure-append-"));
   roots.push(root);
@@ -63,7 +116,10 @@ test("inserts a correction before the terminal event under an exclusive lock", a
   const events = jsonLines(persisted);
   assert.equal(events.at(-2).event_id, correction.event_id);
   assert.equal(events.at(-1).type, "run.finished");
-  assert.deepEqual(events.map((event) => event.sequence), [1, 2, 3, 4]);
+  assert.deepEqual(
+    events.map((event) => event.sequence),
+    [1, 2, 3, 4],
+  );
 });
 
 test("restores historical retrospective corrections before the terminal event", async () => {
@@ -74,13 +130,34 @@ test("restores historical retrospective corrections before the terminal event",
     { type: "run.started", event_id: "RUN:1", sequence: 1, phase: "execution" },
     { type: "usage.recorded", event_id: "RUN:2", sequence: 2, phase: "execution" },
     { type: "run.finished", event_id: "RUN:3", sequence: 3, phase: "execution" },
-    { type: "usage.recorded", event_id: "RUN:4", sequence: 4, phase: "execution", activity_kind: "retrospective_local_remeasurement", retrospective_correction: true },
+    {
+      type: "usage.recorded",
+      event_id: "RUN:4",
+      sequence: 4,
+      phase: "execution",
+      activity_kind: "retrospective_local_remeasurement",
+      retrospective_correction: true,
+    },
   ];
   await writeFile(file, `${records.map((record) => JSON.stringify(record)).join("\n")}\n`, "utf8");
-  await appendRetrospectiveUsage(file, records, { type: "usage.recorded", event_id: "RUN:5", sequence: 5, phase: "execution", activity_kind: "retrospective_local_remeasurement", supersedes_event_id: "RUN:2", retrospective_correction: true });
+  await appendRetrospectiveUsage(file, records, {
+    type: "usage.recorded",
+    event_id: "RUN:5",
+    sequence: 5,
+    phase: "execution",
+    activity_kind: "retrospective_local_remeasurement",
+    supersedes_event_id: "RUN:2",
+    retrospective_correction: true,
+  });
   const events = jsonLines(await readFile(file, "utf8"));
-  assert.deepEqual(events.map((event) => event.event_id), ["RUN:1", "RUN:2", "RUN:4", "RUN:5", "RUN:3"]);
-  assert.deepEqual(events.map((event) => event.sequence), [1, 2, 3, 4, 5]);
+  assert.deepEqual(
+    events.map((event) => event.event_id),
+    ["RUN:1", "RUN:2", "RUN:4", "RUN:5", "RUN:3"],
+  );
+  assert.deepEqual(
+    events.map((event) => event.sequence),
+    [1, 2, 3, 4, 5],
+  );
 });
 
 test("an unavailable lock leaves the original history byte-identical", async () => {

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/source-size-telemetry/model-identity-reconciliation.mjs

@@ -0,0 +1,77 @@
+import { rename, writeFile } from "node:fs/promises";
+
+export async function reconcileGenericModelIdentities({
+  applyBackfill,
+  pricingFor,
+  runs,
+  segments,
+  usageView,
+  withSequence,
+  workspace,
+}) {
+  const segmentsByKey = new Map(segments.map((segment) => [segment.key, segment]));
+  const genericModel = (model) => typeof model === "string" && /^gpt-5$/i.test(model.trim());
+  let correctionsCount = 0;
+  for (const run of runs) {
+    const superseded = new Set(run.usage.map((usage) => usage.supersedes_event_id).filter(Boolean));
+    const effective = run.usage.filter((usage) => !superseded.has(usage.event_id));
+    const corrections = effective.flatMap((usage) => {
+      if (!genericModel(usage.model ?? run.started.model)) return [];
+      const segment = usage.source_segment_key
+        ? (segmentsByKey.get(usage.source_segment_key) ?? null)
+        : null;
+      return segment?.model && !genericModel(segment.model) ? [{ usage, segment }] : [];
+    });
+    correctionsCount += corrections.length;
+    if (!applyBackfill || corrections.length === 0) continue;
+
+    const correctionByTarget = new Map(corrections.map((item) => [item.usage.event_id, item]));
+    const updated = [];
+    let correctionIndex = run.usage.filter(
+      (usage) => usage.activity_kind === "model_identity_reconciliation",
+    ).length;
+    for (const record of run.records) {
+      updated.push(record);
+      const original = usageView(record);
+      const correction = original ? correctionByTarget.get(original.event_id) : null;
+      if (!correction) continue;
+      correctionIndex += 1;
+      const cost = await pricingFor(workspace, correction.segment.model, original.tokens);
+      updated.push({
+        schema_version: 2,
+        event_id: `${run.started.run_id}:model:${String(correctionIndex).padStart(6, "0")}`,
+        run_id: run.started.run_id,
+        sequence: 0,
+        occurred_at: original.occurred_at,
+        type: "usage.recorded",
+        phase: original.phase,
+        activity_kind: "model_identity_reconciliation",
+        classification_source: original.classification_source ?? "current_context",
+        tokens: original.tokens,
+        cost,
+        provider: original.provider ?? run.started.provider ?? "openai",
+        model: correction.segment.model,
+        source_segment_key: original.source_segment_key,
+        supersedes_event_id: original.event_id,
+        source_occurred_at:
+          original.source_occurred_at ??
+          correction.segment.finished_at ??
+          correction.segment.started_at,
+        ...(original.context_stats === undefined ? {} : { context_stats: original.context_stats }),
+        runtime: {
+          reasoning_effort: correction.segment.effort ?? original.runtime?.reasoning_effort ?? null,
+          service_tier: correction.segment.service_tier ?? original.runtime?.service_tier ?? null,
+        },
+      });
+    }
+    const resequenced = updated.map((record, index) => withSequence(record, index + 1));
+    const temporary = `${run.file}.model.tmp`;
+    await writeFile(
+      temporary,
+      `${resequenced.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, run.file);
+  }
+  return correctionsCount;
+}

package/templates/.agents/skills/zaip-skill-release-qualification/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: zaip-skill-release-qualification
+description: Qualify an exact ZAIP release candidate through source-template-package parity, cleanroom, smoke, and candidate-specific evidence; use before a release or publication decision.
+---
+
+# Qualify a release candidate
+
+Use before deciding whether a concrete candidate is ready. It does not publish.
+
+1. Identify the exact candidate revision, version, and intended distribution surface.
+   Do not substitute current working-tree checks for candidate evidence.
+2. Validate framework lock, source-to-public-template parity, generated artifacts,
+   package contents, and version alignment. Treat any source/template/package drift as
+   a failed candidate.
+3. Run the relevant smoke and cleanroom checks against that candidate and preserve the
+   commands, revision, outcomes, and unresolved limits as evidence.
+4. Separate local qualification, remote GitHub CI, registry publication, and formal
+   lifecycle closure. A matching SHA or passing local gate does not prove terminal CI.
+5. Route an explicit push, deploy, or GitHub publication request to
+   `$zaip-skill-github-deploy`; never publish as part of qualification.

package/templates/.agents/skills/zaip-skill-release-qualification/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ZAIP Release Qualification"
+  short_description: "Qualify an exact release candidate without publishing it."
+  default_prompt: "Use $zaip-skill-release-qualification to qualify this exact ZAIP release candidate for source-template-package parity, smoke, and cleanroom evidence."

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

@@ -16,3 +16,8 @@ Esta skill é read-only. Um pedido de revisão não autoriza corrigir, concluir
 7. Correções aprovadas exigem autorização separada e começam uma nova Task. Inicie seu Run com `--work-type rework`, relacione somente IDs já conhecidos e deixe ancestral desconhecido como `null`; nunca leia todo o histórico para adivinhar vínculos. A revisão original permanece imutável.
 8. Valide o perfil quantitativo e semântico por mínimos, sem quotas máximas: `lite` exige pelo menos uma validação e uma Evidence, normalmente uma de cada, mas aceita extras legítimos; `standard` exige pelo menos duas validações no perfil base ou três no elevado e ao menos uma Evidence consolidada; `critical` exige três ou mais validações, quality review independente e somente os controles acionados pelos sinais persistidos; SPEC/PRD exigem três ou mais validações e Evidences parentais, matriz, integração e review independente.
 9. Para cleanroom, ambiente representativo ou produção, confira hash do candidato, identidade do ambiente, reviewer independente e Run observado; teste local não promove esses estados.
+10. Leia [o contrato de prova observável](../zaip-skill-change/references/observable-evidence.md) e confronte cenário, expectativa e observação por AC. Diferencie prova confirmada, limitada, pendente, reprovada e modalidade não aplicável; observações não substituem Validation/Evidence aprovadas. Não transfira aprovação entre Runs nem conte uma limitação como prova suficiente.
+
+# Revisão visual condicional
+
+Não aprove UI visual apenas por source ou typecheck: exija render de cada consumidor e bundle servido quando aplicável, além de screenshot real examinado do estado pedido. Após o fallback finito, browser indisponível deixa browser proof como unknown e o AC visual pendente, sem bloquear prova técnica ou trabalho independente. Ausência de impacto visual admite N/A justificado, não ausência de ferramenta.

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

@@ -10,7 +10,7 @@ description: Create and validate project ZAIP Rules while preserving core Rules.
 3. Crie ou refine `.agents/rules/<nome>.md` com ID `RULE-*` único; `load` em `always`, `auto`, `file_match` ou `manual`; `priority` em `critical`, `high`, `medium` ou `low`; `max_context_tokens` positivo; `requires` com IDs existentes. Exija `globs` não vazios quando `load: file_match`.
 4. Escreva regras pequenas, imperativas e verificáveis; mova explicações extensas para Requirements ou documentação.
 5. Detecte contradições, ciclos de `requires`, duplicação de IDs e budgets excessivos.
-6. Rode `zaip doctor` e `zaip context validate --query "<cenário da Rule>"`; quando a orientação publicada mudar, rode `zaip adapters build` e `zaip adapters check`.
+6. Rode `zaip doctor` e use `zaip context inventory`, `zaip context build` ou `zaip context inspect` conforme o cenário da Rule; quando a orientação publicada mudar, rode `zaip adapters build` e `zaip adapters check`.
 
 ## Ownership
 

package/templates/.agents/skills/zaip-skill-sales-methodology/SKILL.md

@@ -5,6 +5,12 @@ description: Design evidence-backed sales processes, qualification playbooks, an
 
 # Metodologia comercial
 
+## Localização canônica
+
+Salve processos comerciais, playbooks, scripts internos, matrizes de objeções e materiais de enablement em `.agents/sales/`. Não salve esses artefatos em `docs/`, na raiz do repositório ou em diretórios de brand, marketing ou growth.
+
+O arquivo central da área é `.agents/sales/playbook.md`; atualize-o quando uma decisão mudar o processo comercial, qualificação, handoff ou narrativa sales-facing. Materiais específicos podem ser arquivos adicionais na mesma pasta.
+
 1. Delimite empresa, oferta, ICP, persona, canal, origem inbound/outbound, etapa, nível de awareness, complexidade, ticket, ciclo, regiões, compliance e autoridade. Separe fato, evidência, hipótese e decisão; não fabrique consciência, urgência, prova, ROI, preço ou autoridade.
 2. Desenhe um playbook por etapa com objetivo, dono, entrada, abertura, perguntas, evidência, campos SPIN/BANT, transição, objeções, prova autorizada, microcompromisso, saída, CRM, handoff/SLA e próximo passo. Inclua caminhos de not-qualified, nurture e no-decision.
 3. Use as três etapas ZAIP: descoberta/pré-qualificação (tipicamente SDR), alinhamento/qualificação com handoff definido para closer, e fechamento/negociação pelo closer. O preço só pode ser apresentado como aprovado; proposta e contrato seguem o handoff autorizado.

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

@@ -43,3 +43,7 @@ SPEC é opcional para trabalho técnico amplo; Task-first continua válida para
 1. Antes de entregar uma SPEC, construa a matriz parental completa de ACs e produza pelo menos três validações e três Evidences próprias; resultados das Tasks não substituem esta camada.
 2. As modalidades mínimas são integração, spec review e quality review. O review é de autor e Run diferentes, e todos os artefatos usam o commit final esperado.
 3. Uma SPEC com Tasks `lite` continua usando rigor parental: a redução vale para a Task avulsa, não para a alegação integrada da SPEC.
+
+# UI visual condicional
+
+Quando a SPEC afetar UI, declare cada consumidor e gates de render exato; inclua bundle servido apenas se a distribuição/preview for afetada.

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

@@ -1,96 +1,28 @@
 ---
 name: zaip-skill-sqlite-read-model
-description: Install the Node.js prerequisite and create, incrementally update, validate, or rebuild the disposable SQLite read model from canonical ZAIP records.
+description: Install, refresh, validate, or rebuild the disposable SQLite read model from canonical ZAIP records; use for schema drift or local dashboard data failures.
 ---
 
 # SQLite read model
 
-Use this skill when installing, refreshing, or rebuilding the disposable SQLite
-read model. The canonical inputs are `.agents/records` and `.agents/config`;
-never load lifecycle overviews, dashboard projections, or other aggregates as
-an input.
-
-## Prerequisite and rebuild
-
-1. Confirm Node.js 22 or newer with `node --version`. If it is absent, install
-   the LTS release with `winget install --id OpenJS.NodeJS.LTS --exact` and
-   restart the terminal if `node` is still not on `PATH`.
-2. Rebuild the local runtime before rebuilding SQLite. The rebuild script imports
-   `packages/local-runtime/dist/server.cjs`; using an old bundle can create an
-   old schema even when `src/sqlite-read-model.ts` is current.
-3. Prefer the normal incremental refresh on dashboard startup. Do a full rebuild
-   after any schema/view/index change or when validation detects drift.
-4. Keep database files under `.local` (or another disposable local path),
-   untracked. Do not make DBeaver or a SQLite server a dependency.
-
-```powershell
-node .agents/dashboard/packages/local-runtime/scripts/build-sqlite-runtime.mjs
-node .agents/dashboard/packages/local-runtime/scripts/rebuild-sqlite-read-model.mjs
-```
-
-If Windows reports `EPERM` or `EBUSY` replacing
-`.local/dashboard-sqlite/read-model.sqlite`, a live dashboard owns that file.
-Do not treat its old schema as validation evidence. Rebuild and validate an
-isolated generation instead:
-
-```powershell
-$env:ZAIP_SQLITE_DB_PATH = (Join-Path $PWD '.local/dashboard-sqlite/read-model-verify.sqlite')
-node .agents/dashboard/packages/local-runtime/scripts/rebuild-sqlite-read-model.mjs
-node .agents/dashboard/packages/local-runtime/scripts/validate-sqlite-read-model.mjs
-```
-
-Clear `ZAIP_SQLITE_DB_PATH` after the isolated check when the shell will start
-the normal dashboard again.
-
-## Current persisted schema and objective verification
-
-The current generator (`packages/local-runtime/src/sqlite-read-model.ts`) owns
-the schema. At schema version 60 it persists exactly these tables:
-
-- `zaip_aios_activities`
-- `zaip_dim_zaip_agent`
-- `zaip_dim_llm_model`
-- `zaip_dim_provider`
-- `cost_invocation_dimension_facts`
-
-Temporary staging tables and compatibility aliases are connection-local and are
-not persisted. Persisted views use exactly one `zaip_vw_` prefix; query them
-through the documented runtime view names rather than creating duplicate
-unprefixed objects. The generator also requires the activity, cost-dimension,
-and unique run indexes listed below.
-
-After every full rebuild, run this check against the same database generation.
-It verifies database integrity, the exact table inventory, view namespace and
-compilability, and the required indexes. It exits non-zero on drift.
-
-```powershell
-@'
-import assert from 'node:assert/strict';
-import { DatabaseSync } from 'node:sqlite';
-import { resolve } from 'node:path';
-
-const databasePath = process.env.ZAIP_SQLITE_DB_PATH ?? resolve('.local/dashboard-sqlite/read-model.sqlite');
-const database = new DatabaseSync(databasePath, { readOnly: true });
-try {
-  assert.equal(database.prepare('PRAGMA integrity_check').get().integrity_check, 'ok');
-  const objects = database.prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'").all();
-  const tables = objects.filter(({ type }) => type === 'table').map(({ name }) => name).sort();
-  assert.deepEqual(tables, ['cost_invocation_dimension_facts', 'zaip_aios_activities', 'zaip_dim_llm_model', 'zaip_dim_provider', 'zaip_dim_zaip_agent']);
-  const views = objects.filter(({ type }) => type === 'view').map(({ name }) => name);
-  assert.ok(views.length > 0, 'no persisted views');
-  assert.ok(views.every((name) => name.startsWith('zaip_vw_') && !name.startsWith('zaip_vw_vw_')), 'invalid persisted-view prefix');
-  for (const name of views) database.prepare(`SELECT * FROM main."${name.replaceAll('"', '""')}" LIMIT 0`).all();
-  const indexes = new Set(database.prepare("SELECT name FROM sqlite_master WHERE type='index'").all().map(({ name }) => name));
-  for (const name of ['zaip_activities_agent_run', 'zaip_activities_task_day', 'zaip_activities_spec_day', 'zaip_activities_prd_day', 'zaip_activities_run_id', 'zaip_activities_period_invocation', 'cost_dimension_facts_day_model', 'cost_dimension_facts_day_provider', 'cost_dimension_facts_invocation']) assert.ok(indexes.has(name), `missing index ${name}`);
-  console.log(JSON.stringify({ databasePath, tableCount: tables.length, viewCount: views.length, requiredIndexCount: 9 }));
-} finally {
-  database.close();
-}
-'@ | node --input-type=module
-```
-
-The checked-in `validate-sqlite-read-model.mjs` and
-`test-sqlite-read-model.mjs` are the installation gates for schema 60. They
-assert the five persisted tables, the `zaip_vw_` view namespace and required
-indexes against a freshly rebuilt database. Do not use an old database or
-weaken those assertions to hide a schema mismatch.
+Use this skill for the disposable read model. Its only canonical inputs are
+`.agents/records` and `.agents/config`; never use dashboard projections or lifecycle
+overviews as an input.
+
+1. Confirm Node.js 22 or newer. Install its LTS only when the user authorized a
+   prerequisite installation.
+2. Build the local runtime before rebuilding SQLite so the generated database and
+   validation code come from the same runtime revision.
+3. Prefer normal incremental refresh at dashboard startup. Rebuild only after a
+   persisted-contract change or a validation failure.
+4. Keep database files under `.local` (or another disposable ignored location).
+   If Windows reports `EPERM` or `EBUSY`, identify the owning dashboard and validate
+   an isolated generation instead of treating the locked database as evidence.
+5. Run the checked-in rebuild and validation scripts from the local runtime. They
+   are the authority for the current schema version, persisted objects, integrity,
+   views and indexes; do not duplicate those volatile values in this skill.
+6. Rebuild the dashboard artifact when the served runtime is part of the acceptance
+   path, then verify the served health endpoint and the exact affected API/query.
+
+The read model is read-only. A successful database check is technical evidence only;
+browser behavior and lifecycle closure need their own evidence.