@zaip-ai/cli 1.3.2 → 1.3.4

package/templates/.agents/skills/zaip-skill-lifecycle-closure/SKILL.md

@@ -22,6 +22,22 @@ the supplied ID and canonical record; never scan ordinary history to guess a tar
 5. Persist observed evidence before terminal Task, Change, and Execution state; refresh
    manifests before the root Run outcome. Report technical success and formal closure
    separately.
+6. Inventory every affected ID, including prerequisites, failed preparations and retries.
+   Before the last finalizer, verify their canonical states, not only the current root.
+   After failed creation or missing manifest entries, rebuild the manifest and compare
+   it with the canonical records. A finished Run is not proof that its Task, Change,
+   Execution, or sibling work has closed.
+7. Explicit recovery of confirmed inactive legacy work uses `run reconcile --open`
+   with `--orphan-reason inactive_terminal_without_host_identity` and
+   `--orphan-scope` containing the reviewed Run/Task/Execution IDs. Preserve the current
+   delivery and other active work. Do not widen an ID list to `all`, infer inactivity
+   from missing metadata alone, or invent host identity. Persist the reason for blocking
+   work without completion evidence. Re-run the same scope to verify idempotence.
+8. Check source, generated files, framework lock, and evidence scopes before starting
+   an implementation. Reuse the current delivery for its own recovery; do not create
+   a chain of cleanup Tasks to compensate for an incomplete scope or preparation error.
+   Await every delegated result, make the finalizer the last child, and only report
+   closure after all owned work is terminal. A progress handoff is not completion.
 
 Use `$zaip-skill-reconcile-telemetry` only for missing observed usage after lifecycle
 identity is correct; it is not a substitute for closure.

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

@@ -20,6 +20,7 @@ import {
   recordSequence,
   recordType,
   sameCost,
+  selectedRunIdsFromArgs,
   supersedableUsageBeforeTerminal,
   usageStatus,
   usageView,
@@ -42,17 +43,7 @@ const explicitRecovery = process.argv.includes("--explicit-turn-recovery");
 if (timingOnly && !remeasure) {
   throw new Error("--timing-only requires --remeasure");
 }
-const selectedRunIds = new Set(
-  process.argv.flatMap((argument, index, values) =>
-    argument === "--run"
-      ? String(values[index + 1] ?? "")
-          .split(",")
-          .filter(Boolean)
-      : argument.startsWith("--run=")
-        ? argument.slice("--run=".length).split(",").filter(Boolean)
-        : [],
-  ),
-);
+const selectedRunIds = selectedRunIdsFromArgs(process.argv);
 const selectedSessionFiles = process.argv
   .flatMap((argument, index, values) =>
     argument === "--session-file"
@@ -75,6 +66,7 @@ if (apply && deduplicate && selectedRunIds.size === 0) {
   throw new Error("--apply --deduplicate requires at least one explicit --run <RUN-ID>");
 }
 const applyBackfill = apply && !deduplicate && !remeasure && !explicitRecovery;
+const appliesToRun = (runId) => selectedRunIds.size === 0 || selectedRunIds.has(runId);
 
 const runFiles = await filesUnder(join(workspace, ".agents", "records", "runs"), ".jsonl");
 const runs = [];
@@ -82,6 +74,8 @@ const usedKeys = new Set();
 let danglingSupersessionRepairs = 0;
 for (const file of runFiles) {
   let records = jsonLines(await readFile(file, "utf8"));
+  const started = records.find((record) => recordType(record) === "run.started");
+  const applyToCurrentRun = appliesToRun(started?.run_id);
   const finishedRecord = records.find((record) => recordType(record) === "run.finished");
   const canonicalCorrectionTime = finishedRecord
     ? new Date(Date.parse(recordOccurredAt(finishedRecord)) - 1).toISOString()
@@ -93,7 +87,7 @@ for (const file of runFiles) {
         usageView(record)?.activity_kind === "retrospective_local_reconciliation" &&
         recordOccurredAt(record) !== canonicalCorrectionTime,
     );
-  if (applyBackfill && staleCorrectionTime) {
+  if (applyBackfill && applyToCurrentRun && staleCorrectionTime) {
     records = records.map((record) =>
       usageView(record)?.activity_kind === "retrospective_local_reconciliation"
         ? { ...record, occurred_at: canonicalCorrectionTime }
@@ -116,7 +110,7 @@ for (const file of runFiles) {
       .map((usage) => usage.supersedes_event_id)
       .filter(Boolean),
   );
-  if (applyBackfill && nativeMeasured)
+  if (applyBackfill && applyToCurrentRun && nativeMeasured)
     records = records.filter((record) => {
       const usage = usageView(record);
       return (
@@ -132,7 +126,7 @@ for (const file of runFiles) {
     let next = record;
     if (usage.supersedes_event_id !== null && !priorUsageIds.includes(usage.supersedes_event_id)) {
       danglingSupersessionRepairs += 1;
-      if (applyBackfill) {
+      if (applyBackfill && applyToCurrentRun) {
         repairedDangling = true;
         const replacement = priorUsageIds.at(-1) ?? null;
         next = Array.isArray(record)
@@ -147,7 +141,7 @@ for (const file of runFiles) {
     priorUsageIds.push(usage.event_id);
     return next;
   });
-  if (applyBackfill && repairedDangling) {
+  if (applyBackfill && applyToCurrentRun && repairedDangling) {
     const temporary = `${file}.supersession.tmp`;
     await writeFile(
       temporary,
@@ -163,7 +157,7 @@ for (const file of runFiles) {
       index > finishIndex &&
       finishIndex >= 0,
   );
-  if (applyBackfill && (misplaced.length || staleCorrectionTime)) {
+  if (applyBackfill && applyToCurrentRun && (misplaced.length || staleCorrectionTime)) {
     const retained = records.filter((record) => !misplaced.includes(record));
     const insertAt = retained.findIndex((record) => recordType(record) === "run.finished");
     records = [...retained.slice(0, insertAt), ...misplaced, ...retained.slice(insertAt)];
@@ -180,6 +174,7 @@ for (const file of runFiles) {
   );
   if (
     applyBackfill &&
+    applyToCurrentRun &&
     (hasCorrection || nativeMeasured) &&
     records.some((record, index) => recordSequence(record) !== index + 1)
   ) {
@@ -192,7 +187,6 @@ for (const file of runFiles) {
     );
     await rename(temporary, file);
   }
-  const started = records.find((record) => recordType(record) === "run.started");
   const usage = records.filter((record) => recordType(record) === "usage.recorded").map(usageView);
   for (const event of usage)
     if (event.source_segment_key && event.tokens?.total !== null)
@@ -264,7 +258,9 @@ const unfinishedMatches = unfinished.map((run) => ({
 const finishEligible = unfinishedMatches.filter(({ segment }) => segment !== null);
 const finishAmbiguous = unfinishedMatches.filter(({ ambiguous }) => ambiguous);
 if (applyBackfill) {
-  for (const { run, segment } of finishEligible) {
+  for (const { run, segment } of finishEligible.filter(({ run }) =>
+    appliesToRun(run.started.run_id),
+  )) {
     const sequence = Math.max(...run.records.map((record) => recordSequence(record) ?? 0)) + 1;
     const finished = {
       schema_version: 2,
@@ -300,6 +296,7 @@ let repricedEvents = 0;
 let repricedRuns = 0;
 if (reprice) {
   for (const run of runs) {
+    if (applyBackfill && !appliesToRun(run.started.run_id)) continue;
     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 = [];
@@ -361,6 +358,7 @@ if (reprice) {
 
 const modelIdentityCorrections = await reconcileGenericModelIdentities({
   applyBackfill,
+  selectedRunIds,
   pricingFor,
   runs,
   segments: allSegments,
@@ -703,6 +701,7 @@ const ambiguousRunIds = [
   ]),
 ];
 const matchedIds = new Set(eligible.map(({ run }) => run.started.run_id));
+const scopedFinishEligible = finishEligible.filter(({ run }) => appliesToRun(run.started.run_id));
 const corrections = runs.flatMap((run) =>
   run.usage.filter((usage) => usage.activity_kind === "retrospective_local_reconciliation"),
 );
@@ -749,7 +748,7 @@ console.log(
       missing_before: missing.length,
       unfinished_before: unfinished.length,
       unfinished_finish_eligible: finishEligible.length,
-      unfinished_finish_applied: applyBackfill ? finishEligible.length : 0,
+      unfinished_finish_applied: applyBackfill ? scopedFinishEligible.length : 0,
       unfinished_finish_ambiguous: finishAmbiguous.length,
       eligible: eligible.length,
       applied: applyBackfill ? eligible.length : 0,
@@ -789,7 +788,7 @@ console.log(
       model_identity_corrections: modelIdentityCorrections,
       dangling_supersession_repairs: danglingSupersessionRepairs,
       eligible_run_ids: eligible.map(({ run }) => run.started.run_id),
-      finish_eligible_run_ids: finishEligible.map(({ run }) => run.started.run_id),
+      finish_eligible_run_ids: scopedFinishEligible.map(({ run }) => run.started.run_id),
       confidence: Object.fromEntries(
         eligible.map(({ run, confidence }) => [run.started.run_id, confidence]),
       ),

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

@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+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 { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const roots = [];
+const run = promisify(execFile);
+const script = fileURLToPath(new URL("./reconcile-local-telemetry.mjs", import.meta.url));
+
+after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
+
+test("apply with --run leaves unselected historical corrections byte-identical", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-reconcile-scope-"));
+  roots.push(root);
+  const records = join(root, ".agents", "records", "runs", "2026", "08");
+  const selectedFile = join(records, "RUN-SELECTED.jsonl");
+  const unselectedFile = join(records, "RUN-UNSELECTED.jsonl");
+  const sessionFile = join(root, "selected-session.jsonl");
+
+  await mkdir(records, { recursive: true });
+
+  await writeFile(
+    selectedFile,
+    `${[
+      started("RUN-SELECTED", "turn-selected"),
+      finished("RUN-SELECTED", "2026-08-31T12:01:00.000Z"),
+    ]
+      .map(JSON.stringify)
+      .join("\n")}\n`,
+  );
+  const unselected = `${[
+    started("RUN-UNSELECTED", "turn-unselected"),
+    usage("RUN-UNSELECTED:000002", "2026-08-31T12:00:20.000Z", null),
+    usage("RUN-UNSELECTED:reconcile:000003", "2026-08-31T12:00:30.000Z", "RUN-UNSELECTED:000002"),
+    finished("RUN-UNSELECTED", "2026-08-31T12:01:00.000Z"),
+  ]
+    .map(JSON.stringify)
+    .join("\n")}\n`;
+  await writeFile(unselectedFile, unselected);
+  await writeFile(
+    sessionFile,
+    `${[
+      {
+        timestamp: "2026-08-31T12:00:00.000Z",
+        type: "session_meta",
+        payload: { id: "session", cwd: root },
+      },
+      {
+        timestamp: "2026-08-31T12:00:01.000Z",
+        type: "event_msg",
+        payload: { type: "task_started", turn_id: "turn-selected" },
+      },
+      {
+        timestamp: "2026-08-31T12:00:20.000Z",
+        type: "event_msg",
+        payload: {
+          type: "token_count",
+          info: {
+            last_token_usage: {
+              input_tokens: 10,
+              cached_input_tokens: 2,
+              output_tokens: 4,
+              reasoning_output_tokens: 1,
+              total_tokens: 14,
+            },
+          },
+        },
+      },
+      {
+        timestamp: "2026-08-31T12:00:30.000Z",
+        type: "event_msg",
+        payload: { type: "task_complete", turn_id: "turn-selected" },
+      },
+    ]
+      .map(JSON.stringify)
+      .join("\n")}\n`,
+  );
+
+  await run(
+    process.execPath,
+    [script, "--apply", "--run", "RUN-SELECTED", "--session-file", sessionFile],
+    {
+      cwd: root,
+    },
+  );
+
+  assert.equal(await readFile(unselectedFile, "utf8"), unselected);
+  const selected = await readFile(selectedFile, "utf8");
+  assert.match(selected, /retrospective_local_reconciliation/);
+  assert.match(selected, /"total":14/);
+});
+
+function started(runId, turnId) {
+  return {
+    schema_version: 2,
+    event_id: `${runId}:000001`,
+    run_id: runId,
+    sequence: 1,
+    occurred_at: "2026-08-31T12:00:00.000Z",
+    type: "run.started",
+    phase: "execution",
+    client_turn_id: turnId,
+    model: "gpt-5.6-terra",
+  };
+}
+
+function usage(eventId, occurredAt, supersedes) {
+  return {
+    schema_version: 2,
+    event_id: eventId,
+    run_id: "RUN-UNSELECTED",
+    sequence: eventId.endsWith("000002") ? 2 : 3,
+    occurred_at: occurredAt,
+    type: "usage.recorded",
+    phase: "execution",
+    activity_kind: eventId.includes("reconcile")
+      ? "retrospective_local_reconciliation"
+      : "implementation",
+    tokens: { input: 1, cached_input: 0, output: 1, reasoning: 0, total: 2 },
+    cost: { usd: 0.001, brl: 0.005 },
+    provider: "openai",
+    model: "gpt-5.6-terra",
+    source_segment_key: null,
+    supersedes_event_id: supersedes,
+  };
+}
+
+function finished(runId, occurredAt) {
+  return {
+    schema_version: 2,
+    event_id: `${runId}:000004`,
+    run_id: runId,
+    sequence: runId === "RUN-SELECTED" ? 2 : 4,
+    occurred_at: occurredAt,
+    type: "run.finished",
+    phase: "execution",
+    status: "completed",
+  };
+}

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

@@ -48,6 +48,20 @@ export function jsonLines(text) {
     });
 }
 
+export function selectedRunIdsFromArgs(args) {
+  return new Set(
+    args.flatMap((argument, index, values) =>
+      argument === "--run"
+        ? String(values[index + 1] ?? "")
+            .split(",")
+            .filter(Boolean)
+        : argument.startsWith("--run=")
+          ? argument.slice("--run=".length).split(",").filter(Boolean)
+          : [],
+    ),
+  );
+}
+
 export function recordType(record) {
   if (!Array.isArray(record)) return record.type;
   return record[1] === "u"

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

@@ -146,7 +146,9 @@ export function timingEnrichmentRunIds({ remeasure, applyBackfill, selectedRunId
     runs
       .filter(
         (run) =>
-          run.nativeMeasured && run.records.some((record) => recordType(record) === "run.finished"),
+          (selectedRunIds.size === 0 || selectedRunIds.has(run.started.run_id)) &&
+          run.nativeMeasured &&
+          run.records.some((record) => recordType(record) === "run.finished"),
       )
       .map((run) => run.started.run_id),
   );

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

@@ -37,6 +37,27 @@ test("selects completed native Runs for default timing-only backfill", () => {
   assert.deepEqual([...selected], ["RUN-NATIVE"]);
 });
 
+test("limits automatic timing enrichment to explicit Run selection", () => {
+  const selected = timingEnrichmentRunIds({
+    remeasure: false,
+    applyBackfill: true,
+    selectedRunIds: new Set(["RUN-SELECTED"]),
+    runs: [
+      {
+        nativeMeasured: true,
+        started: { run_id: "RUN-SELECTED" },
+        records: [{ type: "run.started" }, { type: "run.finished" }],
+      },
+      {
+        nativeMeasured: true,
+        started: { run_id: "RUN-UNSELECTED" },
+        records: [{ type: "run.started" }, { type: "run.finished" }],
+      },
+    ],
+  });
+  assert.deepEqual([...selected], ["RUN-SELECTED"]);
+});
+
 test("explicit recovery requires exact session identity, unused turns, model/effort, and SPEC text", () => {
   const run = {
     started: {

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

@@ -2,6 +2,7 @@ import { rename, writeFile } from "node:fs/promises";
 
 export async function reconcileGenericModelIdentities({
   applyBackfill,
+  selectedRunIds = new Set(),
   pricingFor,
   runs,
   segments,
@@ -13,6 +14,8 @@ export async function reconcileGenericModelIdentities({
   const genericModel = (model) => typeof model === "string" && /^gpt-5$/i.test(model.trim());
   let correctionsCount = 0;
   for (const run of runs) {
+    if (applyBackfill && selectedRunIds.size > 0 && !selectedRunIds.has(run.started.run_id))
+      continue;
     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) => {

package/templates/.agents/zaip-aios/guides/26-qualidade-e-release.md

@@ -113,6 +113,35 @@ O guard não remove, move, ignora ou adiciona arquivos ao Git; a limpeza deve
 ser resolvida pelo responsável autorizado, preservando os artefatos anteriores.
 Use o checkout limpo do candidato exato e não publique TGZs de diagnóstico.
 
+## Controles críticos pendentes de prova
+
+Para uma Change que altere diagnóstico de pacote, encerramento/recovery,
+filtragem de conteúdo, SBOM, política de empacotamento ou proteção remota,
+documentar e executar cenários negativos no candidato exato. O contrato deve
+incluir, quando aplicável: dual-doctor de TGZ e corrupção controlada; paridade
+entre `finish` e recovery com Evidence de reviewer filho e rejeição cross-root
+e cross-task; variantes de segredo/binário; identidade do SBOM do artefato
+real; e temporário interno rastreado que não deve entrar no TGZ. A projeção
+exclui `.tmp-run-list.json`; se esse arquivo aparecer no inventário empacotado,
+o guard deve bloquear o pacote, sem apagar o arquivo local.
+
+Um script local de consulta de proteção não demonstra que a branch está
+protegida. Para `main`, o guard implementado é
+`node scripts/validate-github-protection.mjs --repository zaip-ai/zaip-aios --branch main --json`,
+com alias `validate:github-protection`. Se a consulta retornar 403, registre a
+limitação de acesso e mantenha o controle remoto pendente; não contorne a API
+nem declare proteção aplicada. Configurar/aplicar a proteção depende de duas
+pessoas/contas autorizadas e de decisão humana separada.
+
+O alias live é um check manual, separado de CI: restrição de plano ou permissão
+do provedor não deve tornar o CI indiscriminadamente vermelho. Testes locais do
+guard comprovam somente a proposta local; o JSON retornado pela consulta não é
+proteção ativa.
+
+Documentação de contrato, presença de testes ou snapshot não substituem output
+executado, SHA candidato, ambiente, horário real e locator sanitizado. Não
+alegar aprovação final, suporte, SLA ou canal comercial a partir desses gates.
+
 ## Evidência e aprovação
 
 Testes passando comprovam validação técnica. Maturidade formal máxima exige ainda: