@zaip-ai/cli 1.0.6 → 1.0.7

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

@@ -1,361 +0,0 @@
-import { createReadStream } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { createInterface } from "node:readline";
-
-export async function filesUnder(root, suffix) {
-  const output = [];
-  async function visit(path) {
-    let entries;
-    try {
-      entries = await readdir(path, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const child = join(path, entry.name);
-      if (entry.isDirectory()) await visit(child);
-      else if (entry.isFile() && entry.name.endsWith(suffix)) output.push(child);
-    }
-  }
-  await visit(root);
-  return output.sort();
-}
-
-export function jsonLines(text) {
-  return text
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .flatMap((line) => {
-      try {
-        const parsed = JSON.parse(line);
-        if (
-          !Array.isArray(parsed) &&
-          parsed &&
-          parsed.type === undefined &&
-          Object.keys(parsed).every((key) => /^\d+$|^sequence$/.test(key))
-        ) {
-          const numeric = Object.keys(parsed)
-            .filter((key) => /^\d+$/.test(key))
-            .map(Number);
-          return [[...Array(Math.max(...numeric) + 1)].map((_, index) => parsed[index])];
-        }
-        return [parsed];
-      } catch {
-        return [];
-      }
-    });
-}
-
-export function recordType(record) {
-  if (!Array.isArray(record)) return record.type;
-  return record[1] === "u"
-    ? "usage.recorded"
-    : record[1] === "f"
-      ? "run.finished"
-      : record[1] === "s"
-        ? "run.started"
-        : null;
-}
-
-export function recordSequence(record) {
-  return Array.isArray(record) ? record[3] : record.sequence;
-}
-
-export function recordOccurredAt(record) {
-  return Array.isArray(record) ? record[4] : record.occurred_at;
-}
-
-export function usageView(record) {
-  if (recordType(record) !== "usage.recorded") return null;
-  if (!Array.isArray(record)) return record;
-  const tokens = record[8] ?? [];
-  const cost = record[9] ?? [];
-  return {
-    event_id: record[2],
-    occurred_at: record[4],
-    phase: record[5],
-    classification_source: record[7],
-    tokens: {
-      input: tokens[0] ?? null,
-      cached_input: tokens[1] ?? null,
-      output: tokens[2] ?? null,
-      reasoning: tokens[3] ?? null,
-      total: tokens[4] ?? null,
-      source: tokens[5] ?? "unavailable",
-    },
-    source_segment_key: record[12] ?? null,
-    supersedes_event_id: record[13] ?? null,
-    activity_kind: record[6] ?? null,
-    cost: { usd: cost[0] ?? null, brl: cost[1] ?? null },
-    provider: record[10] ?? null,
-    model: record[11] ?? null,
-    source_occurred_at: record[14] ?? null,
-    context_stats: Array.isArray(record[15])
-      ? {
-          initial_pack_tokens: record[15][0],
-          tool_output_tokens: record[15][1],
-          files_opened: record[15][2],
-          snippets_opened: record[15][3],
-        }
-      : undefined,
-    runtime: Array.isArray(record[16])
-      ? { reasoning_effort: record[16][0], service_tier: record[16][1] }
-      : undefined,
-  };
-}
-
-export function withSequence(record, sequence) {
-  if (!Array.isArray(record)) return { ...record, sequence };
-  const copy = [...record];
-  copy[3] = sequence;
-  return copy;
-}
-
-function canonicalSegmentKey(sourceSegmentKey) {
-  const marker = sourceSegmentKey.lastIndexOf("@RUN-");
-  const withoutRun = marker < 0 ? sourceSegmentKey : sourceSegmentKey.slice(0, marker);
-  const normalized = withoutRun.replaceAll("\\", "/");
-  const sessionsMarker = normalized.toLowerCase().lastIndexOf("/sessions/");
-  return (sessionsMarker < 0 ? normalized : normalized.slice(sessionsMarker + 1)).toLowerCase();
-}
-
-export function usageStatus(usage) {
-  const superseded = new Set(usage.map((event) => event.supersedes_event_id).filter(Boolean));
-  const effective = usage.filter((event) => !superseded.has(event.event_id));
-  return {
-    effective,
-    measured: effective.some(
-      (event) => event.tokens?.input !== null && event.tokens?.output !== null,
-    ),
-    deduplicated: effective.some(
-      (event) => event.activity_kind === "duplicate_segment_reconciliation",
-    ),
-  };
-}
-
-export function duplicateUsageAssignments(runs) {
-  const groups = new Map();
-  for (const run of runs) {
-    for (const usage of usageStatus(run.usage).effective) {
-      if (
-        !usage.source_segment_key ||
-        usage.tokens?.input === null ||
-        usage.tokens?.output === null
-      ) {
-        continue;
-      }
-      const baseSegmentKey = canonicalSegmentKey(usage.source_segment_key);
-      const signature = JSON.stringify([
-        baseSegmentKey,
-        run.started.client_turn_id ?? null,
-        usage.tokens.input,
-        usage.tokens.cached_input,
-        usage.tokens.output,
-        usage.tokens.reasoning,
-        usage.tokens.total,
-      ]);
-      groups.set(signature, [
-        ...(groups.get(signature) ?? []),
-        { run, usage, base_segment_key: baseSegmentKey },
-      ]);
-    }
-  }
-  return [...groups.values()]
-    .filter((group) => new Set(group.map(({ run }) => run.started.run_id)).size > 1)
-    .map((group) =>
-      [...group].sort(
-        (left, right) =>
-          String(left.run.started.occurred_at).localeCompare(
-            String(right.run.started.occurred_at),
-          ) || left.run.started.run_id.localeCompare(right.run.started.run_id),
-      ),
-    );
-}
-
-export function exactCompletedSegment(started, segments) {
-  if (!started?.client_turn_id) return { segment: null, ambiguous: false };
-  const runStartedAt = Date.parse(started.occurred_at ?? "");
-  const matches = segments.filter((segment) => {
-    if (segment.turn_id !== started.client_turn_id || !segment.finished_at) return false;
-    const segmentFinishedAt = Date.parse(segment.finished_at);
-    return (
-      Number.isFinite(runStartedAt) &&
-      Number.isFinite(segmentFinishedAt) &&
-      segmentFinishedAt >= runStartedAt
-    );
-  });
-  return {
-    segment: matches.length === 1 ? matches[0] : null,
-    ambiguous: matches.length > 1,
-  };
-}
-
-function normalized(path) {
-  return resolve(path).replaceAll("\\", "/").toLowerCase();
-}
-
-export async function loadSegments(workspace) {
-  const sessionFiles = await filesUnder(join(homedir(), ".codex", "sessions"), ".jsonl");
-  const segments = [];
-  for (const file of sessionFiles) {
-    let workspaceMatches = false;
-    let sessionId = null;
-    let current = null;
-    let index = 0;
-    let model = null;
-    let effort = null;
-    let serviceTier = null;
-    const lines = createInterface({
-      input: createReadStream(file, { encoding: "utf8" }),
-      crlfDelay: Infinity,
-    });
-    for await (const line of lines) {
-      let record;
-      try {
-        record = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const payload = record?.payload && typeof record.payload === "object" ? record.payload : null;
-      if (record.type === "session_meta" && typeof payload?.cwd === "string") {
-        workspaceMatches = normalized(payload.cwd) === normalized(workspace);
-        sessionId =
-          typeof payload.session_id === "string"
-            ? payload.session_id
-            : typeof payload.id === "string"
-              ? payload.id
-              : null;
-      }
-      if (!workspaceMatches) continue;
-      const settings = payload?.type === "thread_settings_applied" ? payload.thread_settings : null;
-      if (settings && typeof settings === "object") {
-        if (typeof settings.model === "string") {
-          model = settings.model;
-          if (current) current.model = model;
-        }
-        if (typeof settings.reasoning_effort === "string") {
-          effort = settings.reasoning_effort;
-          if (current) current.effort = effort;
-        }
-        if (typeof settings.service_tier === "string") {
-          serviceTier = settings.service_tier;
-          if (current) current.service_tier = serviceTier;
-        }
-      }
-      if (record.type === "turn_context" && typeof payload?.model === "string") {
-        model = payload.model;
-        if (current) current.model = model;
-      }
-      if (payload?.type === "task_started") {
-        index += 1;
-        current = {
-          key: `${normalized(file)}#${index}`,
-          file,
-          session_id: sessionId,
-          turn_id: typeof payload.turn_id === "string" ? payload.turn_id : null,
-          started_at: record.timestamp ?? null,
-          finished_at: null,
-          model,
-          effort,
-          service_tier: serviceTier,
-          usage: [],
-          raw: [],
-        };
-      }
-      if (!current) continue;
-      if (line.includes("RUN-") || line.includes("TASK-")) current.raw.push(line);
-      if (payload?.type === "token_count") {
-        const usage = payload?.info?.last_token_usage;
-        if (usage && typeof usage === "object")
-          current.usage.push({ ...usage, source_timestamp: record.timestamp ?? null });
-      }
-      if (payload?.type === "task_complete") {
-        current.finished_at = record.timestamp ?? null;
-        if (current.usage.length) segments.push(current);
-        current = null;
-      }
-    }
-    if (current?.usage.length) segments.push(current);
-  }
-  return segments.map((segment) => ({ ...segment, raw: segment.raw.join("\n") }));
-}
-
-export function aggregate(segment) {
-  const result = { input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 };
-  for (const usage of segment.usage) {
-    const input = Number.isFinite(usage.input_tokens) ? usage.input_tokens : 0;
-    const output = Number.isFinite(usage.output_tokens) ? usage.output_tokens : 0;
-    result.input += input;
-    result.cached_input += Number.isFinite(usage.cached_input_tokens)
-      ? usage.cached_input_tokens
-      : 0;
-    result.output += output;
-    result.reasoning += Number.isFinite(usage.reasoning_output_tokens)
-      ? usage.reasoning_output_tokens
-      : 0;
-    result.total += input + output;
-  }
-  return result;
-}
-
-export async function pricingFor(workspace, model, tokens) {
-  let catalog;
-  try {
-    catalog = JSON.parse(
-      await readFile(join(workspace, ".zaip-aios", "pricing", "models.json"), "utf8"),
-    );
-  } catch {
-    return { usd: null, brl: null };
-  }
-  const lower = String(model ?? "").toLowerCase();
-  const matchesIdentity = (identity) => {
-    const normalizedIdentity = identity.toLowerCase();
-    if (lower === normalizedIdentity) return true;
-    const suffix = lower.slice(normalizedIdentity.length);
-    return (
-      suffix.startsWith("@") ||
-      suffix.startsWith(":") ||
-      suffix.startsWith("/") ||
-      /^-\d{4}-\d{2}-\d{2}(?:$|[.:@/])/.test(suffix)
-    );
-  };
-  const price =
-    catalog.models?.find(
-      (item) => matchesIdentity(item.id) || item.aliases?.some(matchesIdentity),
-    ) ?? null;
-  if (!price) return { usd: null, brl: null };
-  const uncached = Math.max(0, tokens.input - tokens.cached_input);
-  const reasoning = Math.max(0, tokens.reasoning ?? 0);
-  const visibleOutput = Math.max(0, tokens.output - reasoning);
-  const longContext =
-    price.long_context_threshold_tokens !== null &&
-    price.long_context_threshold_tokens !== undefined &&
-    tokens.input > price.long_context_threshold_tokens;
-  const inputMultiplier = longContext ? (price.long_context_input_multiplier ?? 1) : 1;
-  const outputMultiplier = longContext ? (price.long_context_output_multiplier ?? 1) : 1;
-  const usd =
-    (uncached * price.input_per_million_usd * inputMultiplier +
-      tokens.cached_input * (price.cached_input_per_million_usd ?? 0) * inputMultiplier +
-      visibleOutput * price.output_per_million_usd * outputMultiplier +
-      reasoning *
-        (price.reasoning_per_million_usd ?? price.output_per_million_usd) *
-        outputMultiplier) /
-    1_000_000;
-  const fxFiles = await filesUnder(join(workspace, ".zaip-aios", "pricing", "fx"), ".json");
-  let rate = null;
-  if (fxFiles.length) {
-    try {
-      rate = JSON.parse(await readFile(fxFiles.at(-1), "utf8")).rate ?? null;
-    } catch {}
-  }
-  return { usd, brl: rate === null ? null : usd * rate };
-}
-
-export function sameCost(left, right) {
-  const close = (a, b) =>
-    (a === null && b === null) ||
-    (typeof a === "number" && typeof b === "number" && Math.abs(a - b) < 0.0000005);
-  return close(left?.usd ?? null, right.usd) && close(left?.brl ?? null, right.brl);
-}

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

@@ -1,187 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { after, test } from "node:test";
-import {
-  aggregate,
-  duplicateUsageAssignments,
-  exactCompletedSegment,
-  jsonLines,
-  pricingFor,
-  recordSequence,
-  recordType,
-  usageStatus,
-  usageView,
-  withSequence,
-} from "./reconcile-telemetry-lib.mjs";
-
-const roots = [];
-after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
-
-test("normalizes compact and object Run records without changing usage totals", () => {
-  const compact = [
-    2,
-    "u",
-    "RUN-1:usage",
-    2,
-    "2026-07-15T22:00:00.000Z",
-    "execution",
-    "test",
-    "current_context",
-    [10, 4, 3, 1, 13, "provider_reported"],
-    [0.1, 0.5],
-  ];
-  const records = jsonLines(
-    `${JSON.stringify({ type: "run.started", sequence: 1 })}\n${JSON.stringify(compact)}\n`,
-  );
-  assert.equal(recordType(records[0]), "run.started");
-  assert.equal(recordType(records[1]), "usage.recorded");
-  assert.equal(recordSequence(records[1]), 2);
-  assert.deepEqual(usageView(records[1]).tokens, {
-    input: 10,
-    cached_input: 4,
-    output: 3,
-    reasoning: 1,
-    total: 13,
-    source: "provider_reported",
-  });
-  assert.equal(recordSequence(withSequence(records[1], 7)), 7);
-  assert.deepEqual(
-    aggregate({
-      usage: [
-        { input_tokens: 10, cached_input_tokens: 4, output_tokens: 3, reasoning_output_tokens: 1 },
-      ],
-    }),
-    {
-      input: 10,
-      cached_input: 4,
-      output: 3,
-      reasoning: 1,
-      total: 13,
-    },
-  );
-});
-
-test("prices only exact or governed model identities", async () => {
-  const root = await mkdtemp(join(tmpdir(), "zaip-reconcile-lib-"));
-  roots.push(root);
-  await mkdir(join(root, ".zaip-aios", "pricing"), { recursive: true });
-  await writeFile(
-    join(root, ".zaip-aios", "pricing", "models.json"),
-    JSON.stringify({
-      models: [
-        {
-          id: "gpt-test",
-          aliases: ["gpt-test-alias"],
-          input_per_million_usd: 10,
-          cached_input_per_million_usd: 1,
-          output_per_million_usd: 20,
-          reasoning_per_million_usd: 30,
-          long_context_threshold_tokens: null,
-        },
-      ],
-    }),
-  );
-  const tokens = { input: 100, cached_input: 40, output: 20, reasoning: 5 };
-  const expected = (60 * 10 + 40 * 1 + 15 * 20 + 5 * 30) / 1_000_000;
-  assert.equal((await pricingFor(root, "gpt-test", tokens)).usd, expected);
-  assert.equal((await pricingFor(root, "unknown", tokens)).usd, null);
-});
-
-test("selects only one completed local segment for an exact Run turn", () => {
-  const started = {
-    client_turn_id: "turn-1",
-    occurred_at: "2026-07-17T12:00:00.000Z",
-  };
-  const completed = {
-    key: "session#1",
-    turn_id: "turn-1",
-    finished_at: "2026-07-17T12:03:00.000Z",
-  };
-  assert.deepEqual(exactCompletedSegment(started, [completed]), {
-    segment: completed,
-    ambiguous: false,
-  });
-  assert.deepEqual(exactCompletedSegment(started, [{ ...completed, finished_at: null }]), {
-    segment: null,
-    ambiguous: false,
-  });
-  assert.deepEqual(
-    exactCompletedSegment(started, [completed, { ...completed, key: "session#2" }]),
-    {
-      segment: null,
-      ambiguous: true,
-    },
-  );
-});
-
-test("detects only exact duplicate segment assignments across Runs", () => {
-  const usage = (
-    runId,
-    total,
-    output = 10,
-    sourcePrefix = "",
-    sourceOccurredAt = "2026-07-17T12:03:00.000Z",
-  ) => ({
-    event_id: `${runId}:usage`,
-    source_segment_key: `${sourcePrefix}sessions/2026/07/17/session.jsonl#1@${runId}`,
-    source_occurred_at: sourceOccurredAt,
-    supersedes_event_id: null,
-    tokens: {
-      input: total - output,
-      cached_input: total - output - 5,
-      output,
-      reasoning: 2,
-      total,
-    },
-  });
-  const run = (runId, occurredAt, total, output, sourcePrefix, sourceOccurredAt) => ({
-    started: {
-      run_id: runId,
-      client_turn_id: "turn-1",
-      occurred_at: occurredAt,
-    },
-    usage: [usage(runId, total, output, sourcePrefix, sourceOccurredAt)],
-  });
-  const first = run("RUN-FIRST", "2026-07-17T12:00:00.000Z", 100);
-  const duplicate = run(
-    "RUN-DUPLICATE",
-    "2026-07-17T12:01:00.000Z",
-    100,
-    undefined,
-    "C:/Users/david/.codex/",
-    "2026-07-17T12:04:00.000Z",
-  );
-  const legitimateDelta = run("RUN-DELTA", "2026-07-17T12:02:00.000Z", 20, 5);
-
-  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"],
-  );
-  assert.equal(groups[0][0].base_segment_key, "sessions/2026/07/17/session.jsonl#1");
-});
-
-test("keeps duplicate reconciliation unavailable and protected from backfill", () => {
-  const original = {
-    event_id: "RUN-DUPLICATE:usage",
-    supersedes_event_id: null,
-    activity_kind: "implementation",
-    tokens: { input: 90, output: 10 },
-  };
-  const correction = {
-    event_id: "RUN-DUPLICATE:deduplicate:000001",
-    supersedes_event_id: original.event_id,
-    activity_kind: "duplicate_segment_reconciliation",
-    tokens: { input: null, output: null },
-  };
-
-  const status = usageStatus([original, correction]);
-
-  assert.equal(status.measured, false);
-  assert.equal(status.deduplicated, true);
-  assert.deepEqual(status.effective, [correction]);
-});

package/templates/.zaip-aios/templates/skills/zaip-skill-requirements/SKILL.md

@@ -1,16 +0,0 @@
----
-name: zaip-skill-requirements
-description: Create, version, validate, and promote ZAIP Requirements and Acceptance Criteria.
----
-
-# Manter Requirements
-
-1. Agrupe Requirements por área estável em `.agents/requirements/<area>.md`; não crie arquivo por Task, mês ou Change.
-2. Use IDs únicos e AC observável/determinístico com método de verificação explícito; rejeite “adequado”, “rápido” ou “funciona” sem limiar.
-3. Faça PRD, SPEC, Change, Task, teste e evidência referenciar IDs sem duplicar a verdade.
-4. Durante planejamento/execução, registre o delta como `proposed` na Change; não reescreva regra ativa antecipadamente.
-5. Para promover a `active`, exija todos os ACs cobertos por evidência, testes/evals terminais, referências válidas e ausência de regressão conhecida.
-6. Registre versão/proveniência; depreque com substituto explícito quando aplicável, sem apagar histórico ainda referenciado.
-7. Valide órfãos, duplicatas, AC sem evidência, aliases e referências quebradas antes de concluir.
-8. Diferencie assurance de Task e de entrega: `lite` usa exatamente 1 validação/1 Evidence, `standard` 2 ou 3, `critical` 3+ com controles independentes; SPEC/PRD adicionam pelo menos 3 validações/3 Evidences parentais, matriz completa e integração real.
-9. Não promova Requirement com evidência de candidato antigo, sem commit/hash quando exigido ou com alegação de ambiente superior ao realmente validado.

package/templates/.zaip-aios/templates/skills/zaip-skill-requirements/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "ZAIP Requirements"
-  short_description: "Maintain deterministic Requirements and Acceptance Criteria."
-  default_prompt: "Use $zaip-skill-requirements to create, validate, or promote traceable Requirements and Acceptance Criteria."

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

@@ -1,18 +0,0 @@
----
-name: zaip-skill-review
-description: Review ZAIP work read-only against Requirements, diff, tests, evidence, and results.
----
-
-# Revisar sem alterar
-
-Esta skill é read-only. Um pedido de revisão não autoriza corrigir, concluir estados nem publicar.
-
-1. Resolva a cadeia PRD/SPEC/Task → Change → Execution/Runs e carregue só Requirements, Rules, diff, testes e evidências relacionados.
-2. Para cada AC, classifique separadamente `implemented`, `evidenced` e `validated_in_production` como `yes`, `no`, `unknown` ou `not_applicable` justificado.
-3. Verifique escopo, regressões, arquitetura, segurança, tratamento de falhas, observabilidade e consistência das decisões.
-4. Não trate teste declarado como teste executado; não trate execução local como validação em produção.
-5. Entregue findings priorizados com arquivo/linha quando possível, impacto, evidência e ação recomendada.
-6. Se não houver findings, declare riscos residuais e lacunas de evidência.
-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: `lite` exatamente 1/1, `standard` exatamente 2/2 ou 3/3, `critical` 3+ e SPEC/PRD com 3+ artefatos parentais, matriz, integração, review independente e commit final.
-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.

package/templates/.zaip-aios/templates/skills/zaip-skill-review/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "ZAIP Review"
-  short_description: "Review changes against evidence and acceptance criteria."
-  default_prompt: "Use $zaip-skill-review to perform a read-only review from Requirements and diff through evidence and results."

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

@@ -1,19 +0,0 @@
----
-name: zaip-skill-rules
-description: Create and validate project ZAIP Rules while preserving core Rules.
----
-
-# Manter Rules do projeto
-
-1. Confirme que a instrução é durável e repetível; preferência temporária deve ficar no trabalho ativo, não virar Rule.
-2. Procure por IDs e temas equivalentes em `.agents/rules/project` e nas Rules ZAIP aplicáveis antes de criar outra.
-3. Crie ou refine somente `.agents/rules/project/<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`.
-
-## Ownership
-
-- `.agents/rules/zaip` é fornecida pelo framework e só muda numa evolução/upgrade explícito do ZAIP.
-- `.agents/rules/project` é específica do repositório, preservada por upgrade e nunca entra no release público.
-- Não crie versões mensais ou uma Rule por Change. Edite a Rule fixa somente quando a regra real mudar; o histórico fica no Git e na Change.

package/templates/.zaip-aios/templates/skills/zaip-skill-rules/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "ZAIP Project Rules"
-  short_description: "Create and validate project-owned ZAIP Rules."
-  default_prompt: "Use $zaip-skill-rules to create or refine project-specific Rules without editing ZAIP core Rules."

package/templates/.zaip-aios/templates/skills/zaip-skill-security/SKILL.md

@@ -1,30 +0,0 @@
----
-name: zaip-skill-security
-description: Assess ZAIP security read-only, compare or verify the zaip-aios-security and zaip-aios-full-access permission profiles, or verify controls during authorized delivery.
----
-
-# Avaliar e verificar segurança
-
-1. Escolha o modo antes de agir:
-   - `assess`: somente leitura; reporte findings provisórios sem editar arquivos, persistir evidência ou mudar estado.
-   - `verify`: use apenas dentro de uma execução já autorizada; rode checks e persista evidência sanitizada na Change/Execution materializada.
-2. Classifique risco e superfície: dados, autenticação/autorização, tenants, rede, filesystem, dependências, CI e supply chain.
-3. Procure segredos e PII sem imprimir valores; masque evidências e nunca persista credenciais em `.agents`.
-4. Verifique menor privilégio, boundary de confiança, validação de entrada, autorização por recurso e isolamento de tenant.
-5. Revise dependências/lockfile, scripts de instalação, artefatos gerados e fontes externas não confiáveis.
-6. Para leitura de dados, imponha filtro, limite, tenant e redaction; diferencie resultado vazio de falta de acesso, RLS ou erro.
-7. Em risco `critical`, exija threat model, rollout, rollback e gates antes de executar.
-8. Mapeie cada finding ou teste a Requirement/AC. No modo `assess`, apenas proponha o vínculo; no `verify`, registre-o sem inventar resultado.
-9. Nunca reduza um controle ou execute replay/recuperação sem autorização explícita e validação de idempotência.
-
-## Perfis de permissão Codex
-
-- Leia `.agents/zaip-aios/guides/10-seguranca.md` ao avaliar, selecionar ou alterar um perfil.
-- Prefira `zaip-aios-security`: use uma tabela da raiz física absoluta do repositório, com `"."`, `.git`, `.agents` e `.codex` como `write`; permita escrita em `~/.ssh` somente para fluxos Git/SSH explicitamente autorizados e limite a rede de comandos a `github.com` com `mode = "limited"`. Não use `extends = ":workspace"` nem `:workspace_roots` para esse perfil no Windows, pois o Codex protege `.agents` e `.codex` nesses modos.
-- Use `approval_policy = "never"`; a autorização de deploy continua sendo exigida pelas Rules, hooks e skills, e a rede nativa do perfil permanece limitada a `github.com`.
-- Trate `zaip-aios-full-access` como exceção de maior risco: ele permite escrita nativa em `C:\` inteiro e rede completa, sujeitas às ACLs e privilégios do Windows.
-- Ao autorizar full access, registre a necessidade e verifique as camadas compensatórias: pedido explícito, escopo do `AGENTS.md`, Rules/skills, hook `PreToolUse`, regras `forbidden`, política GitHub, proteção de segredos, lifecycle sanitizado, subagentes de menor privilégio e controles do sistema operacional.
-- Nunca descreva essas camadas como equivalentes ao isolamento nativo. Elas reduzem risco, mas somente `zaip-aios-security` nega tecnicamente escrita fora do workspace e restringe a rede de comandos ao GitHub.
-- Recomende retornar ao perfil restrito assim que a operação excepcional terminar.
-
-Falha de segurança terminal bloqueia conclusão; incerteza relevante deve ficar explícita, não ser tratada como aprovação.

package/templates/.zaip-aios/templates/skills/zaip-skill-security/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "ZAIP Security"
-  short_description: "Assess profiles and ZAIP security controls."
-  default_prompt: "Use $zaip-skill-security to compare ZAIP permission profiles or verify security controls during authorized work."