@zaip-ai/cli 1.0.8 → 1.3.0

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

@@ -6,23 +6,24 @@ import {
   duplicateUsageImpact,
   exactCompletedSegment,
   filesUnder,
-  jsonLines,
   isExactDuplicateUsageGroup,
+  jsonLines,
   loadSegments,
   pricingFor,
   recordOccurredAt,
   recordSequence,
   recordType,
   sameCost,
+  supersedableUsageBeforeTerminal,
   usageStatus,
   usageView,
-  supersedableUsageBeforeTerminal,
   withSequence,
 } from "./reconcile-telemetry-lib.mjs";
 import {
   remeasureSelectedRuns,
   timingEnrichmentRunIds,
 } from "./reconcile-telemetry-remeasurement.mjs";
+import { reconcileGenericModelIdentities } from "./source-size-telemetry/model-identity-reconciliation.mjs";
 
 const workspace = resolve(process.cwd());
 const apply = process.argv.includes("--apply");
@@ -318,86 +319,35 @@ if (reprice) {
   }
 }
 
-const segmentsByKey = new Map(allSegments.map((segment) => [segment.key, segment]));
-const genericModel = (model) => typeof model === "string" && /^gpt-5$/i.test(model.trim());
-let modelIdentityCorrections = 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 }] : [];
-  });
-  modelIdentityCorrections += 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);
-}
+const modelIdentityCorrections = await reconcileGenericModelIdentities({
+  applyBackfill,
+  pricingFor,
+  runs,
+  segments: allSegments,
+  usageView,
+  withSequence,
+  workspace,
+});
 
 const duplicateGroups = duplicateUsageAssignments(runs);
 const exactDuplicateGroups = duplicateGroups.filter(isExactDuplicateUsageGroup);
 const aliasReviewGroups = duplicateGroups.filter((group) => !isExactDuplicateUsageGroup(group));
-const selectedDuplicateGroups = selectedRunIds.size === 0
-  ? exactDuplicateGroups
-  : exactDuplicateGroups.filter((group) =>
-      group.some(({ run }) => selectedRunIds.has(run.started.run_id)),
-    );
-const selectedAliasReviewGroups = selectedRunIds.size === 0
-  ? aliasReviewGroups
-  : aliasReviewGroups.filter((group) =>
-      group.some(({ run }) => selectedRunIds.has(run.started.run_id)),
-    );
+const selectedDuplicateGroups =
+  selectedRunIds.size === 0
+    ? exactDuplicateGroups
+    : exactDuplicateGroups.filter((group) =>
+        group.some(({ run }) => selectedRunIds.has(run.started.run_id)),
+      );
+const selectedAliasReviewGroups =
+  selectedRunIds.size === 0
+    ? aliasReviewGroups
+    : aliasReviewGroups.filter((group) =>
+        group.some(({ run }) => selectedRunIds.has(run.started.run_id)),
+      );
 const duplicateAssignments = selectedDuplicateGroups.flatMap((group) =>
-  group.slice(1).filter(({ run }) => selectedRunIds.size === 0 || selectedRunIds.has(run.started.run_id)),
+  group
+    .slice(1)
+    .filter(({ run }) => selectedRunIds.size === 0 || selectedRunIds.has(run.started.run_id)),
 );
 let deduplicatedEvents = 0;
 if (apply && deduplicate) {
@@ -641,6 +591,7 @@ for (const candidate of candidates) {
 }
 const eligible = candidates.filter(
   (candidate) =>
+    (selectedRunIds.size === 0 || selectedRunIds.has(candidate.run.started.run_id)) &&
     byRun.get(candidate.run.started.run_id).length === 1 &&
     bySegment.get(candidate.segment.key).length === 1,
 );
@@ -650,7 +601,9 @@ if (applyBackfill) {
     // Re-read each Run under the serial apply loop: a preceding timing repair may
     // have reordered or appended a correction after the initial scan.
     const persistedRecords = jsonLines(await readFile(run.file, "utf8"));
-    const finishIndex = persistedRecords.findIndex((record) => recordType(record) === "run.finished");
+    const finishIndex = persistedRecords.findIndex(
+      (record) => recordType(record) === "run.finished",
+    );
     const insertAt = finishIndex < 0 ? persistedRecords.length : finishIndex;
     const tokens = aggregate(segment);
     const model = segment.model ?? run.started.model ?? null;
@@ -665,7 +618,9 @@ if (applyBackfill) {
       occurred_at: persistedRecords.find((record) => recordType(record) === "run.finished")
         ? new Date(
             Date.parse(
-              recordOccurredAt(persistedRecords.find((record) => recordType(record) === "run.finished")),
+              recordOccurredAt(
+                persistedRecords.find((record) => recordType(record) === "run.finished"),
+              ),
             ) - 1,
           ).toISOString()
         : new Date().toISOString(),
@@ -686,9 +641,11 @@ if (applyBackfill) {
       ...(segment.finished_at ? { source_finished_at: segment.finished_at } : {}),
       runtime: { reasoning_effort: segment.effort, service_tier: segment.service_tier },
     };
-    const updated = [...persistedRecords.slice(0, insertAt), event, ...persistedRecords.slice(insertAt)].map(
-      (record, index) => withSequence(record, index + 1),
-    );
+    const updated = [
+      ...persistedRecords.slice(0, insertAt),
+      event,
+      ...persistedRecords.slice(insertAt),
+    ].map((record, index) => withSequence(record, index + 1));
     const temporary = `${run.file}.reconcile.tmp`;
     await writeFile(
       temporary,

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

@@ -116,12 +116,15 @@ export function supersedableUsageBeforeTerminal(records) {
   const finishIndex = records.findIndex((record) => recordType(record) === "run.finished");
   const beforeTerminal = records.slice(0, finishIndex < 0 ? records.length : finishIndex);
   const usage = beforeTerminal.map(usageView).filter(Boolean);
-  return [...usage]
-    .reverse()
-    .find(
-      (event) =>
-        event.tokens?.total === null && !usage.some((other) => other.supersedes_event_id === event.event_id),
-    ) ?? null;
+  return (
+    [...usage]
+      .reverse()
+      .find(
+        (event) =>
+          event.tokens?.total === null &&
+          !usage.some((other) => other.supersedes_event_id === event.event_id),
+      ) ?? null
+  );
 }
 
 export function withSequence(record, sequence) {
@@ -183,11 +186,13 @@ export function duplicateUsageAssignments(runs) {
   return [...groups.values()]
     .filter((group) => new Set(group.map(({ run }) => run.started.run_id)).size > 1)
     .map((group) =>
-      [...group].sort((left, right) =>
+      [...group].sort(
+        (left, right) =>
           provenanceRank(left.usage) - provenanceRank(right.usage) ||
           String(left.run.started.occurred_at).localeCompare(
             String(right.run.started.occurred_at),
-          ) || left.run.started.run_id.localeCompare(right.run.started.run_id),
+          ) ||
+          left.run.started.run_id.localeCompare(right.run.started.run_id),
       ),
     );
 }

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

@@ -11,8 +11,8 @@ import {
   duplicateUsageImpact,
   exactCompletedSegment,
   exactRemeasurementSegment,
-  jsonLines,
   isExactDuplicateUsageGroup,
+  jsonLines,
   pricingFor,
   recordSequence,
   recordType,
@@ -27,7 +27,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", () => {
@@ -318,11 +339,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 +370,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 +391,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

@@ -63,7 +63,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 +77,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-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-sqlite-read-model/scripts/ensure-node.mjs

@@ -2,17 +2,40 @@ import { execFileSync } from "node:child_process";
 
 const minimumMajor = 22;
 function version() {
-  try { return execFileSync(process.execPath, ["--version"], { encoding: "utf8" }).trim(); } catch { return null; }
+  try {
+    return execFileSync(process.execPath, ["--version"], { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
 }
 const current = version();
 if (current && Number.parseInt(current.slice(1), 10) >= minimumMajor) {
   process.stdout.write(`${current} is ready\n`);
   process.exit(0);
 }
-if (process.platform !== "win32") throw new Error(`Node.js ${minimumMajor}+ is required; automatic installation is only configured for Windows.`);
+if (process.platform !== "win32")
+  throw new Error(
+    `Node.js ${minimumMajor}+ is required; automatic installation is only configured for Windows.`,
+  );
 try {
-  execFileSync("winget", ["install", "--id", "OpenJS.NodeJS.LTS", "--exact", "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit" });
+  execFileSync(
+    "winget",
+    [
+      "install",
+      "--id",
+      "OpenJS.NodeJS.LTS",
+      "--exact",
+      "--accept-source-agreements",
+      "--accept-package-agreements",
+    ],
+    { stdio: "inherit" },
+  );
 } catch (error) {
-  throw new Error("Node.js 22+ is missing and winget could not install the LTS release. Install Node.js manually and retry.", { cause: error });
+  throw new Error(
+    "Node.js 22+ is missing and winget could not install the LTS release. Install Node.js manually and retry.",
+    { cause: error },
+  );
 }
-process.stdout.write("Node.js LTS installation completed. Restart the terminal before running the SQLite generator.\n");
+process.stdout.write(
+  "Node.js LTS installation completed. Restart the terminal before running the SQLite generator.\n",
+);

package/templates/.agents/zaip-aios/INDEX.md

@@ -21,6 +21,16 @@ Use esta pagina como roteador de baixo custo de tokens.
 | Configurar MCPs, APIs e Codex | `guides/15-tools-e-codex.md` |
 | Entender status, Runs e reconciliação | `guides/16-lifecycle-e-reconciliacao.md` |
 | Entender tokens, precificacao e conversao de moeda | `guides/17-como-o-custo-e-calculado.md` |
+| Consultar o catálogo completo de agentes | `guides/18-catalogo-de-agentes.md` |
+| Entender assurance e autonomia | `guides/19-assurance-e-autonomia.md` |
+| Consultar instalação detalhada | `guides/20-instalacao-detalhada.md` |
+| Consultar telemetria do Monitor de Custos | `guides/21-telemetria-monitor-custos.md` |
+| Entender fluxos e roteamento | `guides/22-fluxos-e-roteamento.md` |
+| Consultar a política de modelos | `guides/23-orquestracao-de-modelos.md` |
+| Entender cálculo e fontes de custo OpenAI | `guides/24-calculo-de-custos-openai.md` e `guides/25-fontes-de-precos-openai.md` |
+| Consultar qualidade e release | `guides/26-qualidade-e-release.md` |
+| Entender a telemetria Git-native | `guides/27-telemetria-git-native.md` |
+| Consultar o lifecycle completo | `guides/28-lifecycle-completo.md` |
 | Escolher MCP ou API | `../tools/catalog.yaml` |
 
 Antes de agir, prevalecem `../config/project.yaml`, as Rules aplicaveis e os

package/templates/.agents/zaip-aios/README.md

@@ -35,7 +35,8 @@ Quando houver conflito, prevalece a configuracao do projeto e a regra aplicavel.
 - Use os guias 03 a 06 para Tasks, SPECs, PRDs e execucao com evidencias.
 - Use o guia 09 para delegacao entre os 23 agentes e 6 squads registrados.
 - Use o guia 16 para entender status, reconciliacao e a ordem de finalizacao.
-- Use o guia 17 para interpretar tokens, precificacao e conversao de moeda.
+- Use os guias 17 e 24 a 25 para interpretar tokens, precificacao e conversao de moeda.
+- Use os guias 18 a 28 quando precisar do contrato completo de agentes, lifecycle, telemetria, qualidade, instalacao ou roteamento.
 
 O instalador npm projeta esta pasta da `.agents` canonica para o tarball e a
 recria no projeto consumidor. Arquivos em `public-cli/packages/cli/templates`

package/templates/.agents/zaip-aios/VERSION

@@ -1 +1 @@
-1.0.8
+1.3.0