@zaip-ai/cli 6.3.0 → 7.6.0

package/templates/.agents/skills/zaip-skill-qa/scripts/run-behavior-tests.test.mjs

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import test from "node:test";
+import {
+  behaviorEnvironment,
+  parseTap,
+  runBehaviorTests,
+  validateInput,
+} from "./run-behavior-tests.mjs";
+
+const scriptPath = ".agents/skills/zaip-skill-qa/scripts/run-behavior-tests.mjs";
+const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const product = "export const add = (a, b) => a + b;\n";
+const behavior =
+  "import test from 'node:test'; import assert from 'node:assert/strict'; import { add } from '../src/app.mjs'; test('actual synthetic arithmetic behavior', () => assert.equal(add(2,3),5));\n";
+// Synthetic test data exercises the runner; it is not native AI-generation proof.
+async function fixture(t, testCode = behavior) {
+  const parent = await mkdtemp(join(tmpdir(), "zaip-qa-behavior-"));
+  t.after(async () => {
+    assert.equal(dirname(parent), resolve(tmpdir()));
+    assert.ok(parent.split(/[\\/]/).at(-1).startsWith("zaip-qa-behavior-"));
+    await rm(parent, { recursive: true, force: true, maxRetries: 5 });
+  });
+  const root = join(parent, "qa"),
+    source = join(parent, "framework");
+  const bytes = await readFile(new URL("./run-behavior-tests.mjs", import.meta.url));
+  for (const path of [root, source]) {
+    await mkdir(join(path, dirname(scriptPath)), { recursive: true });
+    await writeFile(join(path, scriptPath), bytes);
+    execFileSync("git", ["init", "-q", "-b", "main"], {
+      cwd: path,
+      stdio: "pipe",
+      windowsHide: true,
+    });
+  }
+  await mkdir(join(root, ".agents/config"), { recursive: true });
+  await mkdir(join(root, ".agents/private/state/qa-inputs"), { recursive: true });
+  await mkdir(join(root, "src"));
+  await mkdir(join(root, "tests"));
+  await writeFile(join(root, "src/app.mjs"), product);
+  await writeFile(join(root, "tests/app.test.mjs"), testCode);
+  const config = {
+    schema_version: 1,
+    purpose: "zaip-aios-qa",
+    repository_root: root,
+    framework_root: source,
+    scope: ["src/**", "tests/**"],
+    created_at: new Date().toISOString(),
+  };
+  await writeFile(join(root, ".agents/config/qa.json"), JSON.stringify(config));
+  const input = {
+    schema_version: 1,
+    scenario_id: "generate-backend",
+    challenge: "a".repeat(32),
+    products: [{ path: "src/app.mjs", sha256: sha(product) }],
+    tests: [{ path: "tests/app.test.mjs", sha256: sha(testCode) }],
+  };
+  const name = `.agents/private/state/qa-inputs/AC-QA-${input.challenge}.json`;
+  await writeFile(join(root, name), JSON.stringify(input));
+  return { root, source, input, name };
+}
+
+test("runs real Node tests and returns bound summary without raw source or TAP", async (t) => {
+  const f = await fixture(t);
+  const result = await runBehaviorTests(f.root, f.name),
+    proof = result.qa_generation;
+  assert.equal(proof.status, "passed");
+  assert.equal(proof.exit_code, 0);
+  assert.equal(proof.tap.tests, 1);
+  assert.equal(proof.tap.pass, 1);
+  assert.equal(proof.tap.fail, 0);
+  assert.equal(proof.tap.skipped, 0);
+  assert.equal(proof.script_sha256, sha(await readFile(join(f.source, scriptPath))));
+  assert.equal(proof.input_sha256, sha(await readFile(join(f.root, f.name))));
+  assert.equal(JSON.stringify(result).includes(product), false);
+  assert.equal(JSON.stringify(result).includes("TAP version"), false);
+});
+
+test("does not turn empty files or zero executed tests into success", async (t) => {
+  const empty = await fixture(t, "   \n");
+  await assert.rejects(runBehaviorTests(empty.root, empty.name), /empty_behavior/);
+  const none = await fixture(t, "// nonempty source with no tests\n");
+  const emptyResult = await runBehaviorTests(none.root, none.name);
+  assert.equal(emptyResult.qa_generation.status, "failed");
+  assert.throws(
+    () => parseTap("# tests 0\n# pass 0\n# fail 0\n# cancelled 0\n# skipped 0\n# todo 0\n"),
+    /zero_tests/,
+  );
+});
+
+test("requires every executed test to pass without skipped or todo cases", async (t) => {
+  for (const code of [
+    "import test from 'node:test';test.skip('skipped case',()=>{});\n",
+    "import test from 'node:test';test.todo('unimplemented case');\n",
+    "import test from 'node:test';import assert from 'node:assert/strict';test('fails',()=>assert.equal(1,2));\n",
+  ]) {
+    const f = await fixture(t, code);
+    assert.equal((await runBehaviorTests(f.root, f.name)).qa_generation.status, "failed");
+  }
+});
+
+test("drops secret/provider/Node injection environment instead of propagating it to tests", async (t) => {
+  const original = process.env.QA_SECRET_CANARY;
+  process.env.QA_SECRET_CANARY = "synthetic-canary-never-log";
+  try {
+    assert.equal(behaviorEnvironment().QA_SECRET_CANARY, undefined);
+    assert.equal(behaviorEnvironment().NODE_OPTIONS, undefined);
+    assert.equal(behaviorEnvironment().SSH_AUTH_SOCK, undefined);
+    const f = await fixture(
+      t,
+      "import test from 'node:test';import assert from 'node:assert/strict';test('no credential env',()=>{assert.equal(process.env.QA_SECRET_CANARY,undefined);assert.equal(process.env.NODE_OPTIONS,undefined)});\n",
+    );
+    assert.equal((await runBehaviorTests(f.root, f.name)).qa_generation.status, "passed");
+  } finally {
+    if (original === undefined) delete process.env.QA_SECRET_CANARY;
+    else process.env.QA_SECRET_CANARY = original;
+  }
+});
+
+test("refuses arbitrary commands, path traversal, mismatched input identity and opt-in absence", async (t) => {
+  const f = await fixture(t);
+  assert.throws(() => validateInput({ ...f.input, command: "node --version" }), /fields/);
+  assert.throws(
+    () =>
+      validateInput({
+        ...f.input,
+        tests: [{ path: "../outside.test.mjs", sha256: "a".repeat(64) }],
+      }),
+    /path/,
+  );
+  await assert.rejects(
+    runBehaviorTests(f.root, ".agents/private/state/qa-inputs/arbitrary.json"),
+    /challenge_scope/,
+  );
+  await rm(join(f.root, ".agents/config/qa.json"));
+  await assert.rejects(runBehaviorTests(f.root, f.name));
+});
+
+test("rejects code hash drift, managed-script drift and junction traversal before executing tests", async (t) => {
+  const f = await fixture(t);
+  await writeFile(join(f.root, "src/app.mjs"), "changed");
+  await assert.rejects(runBehaviorTests(f.root, f.name), /hash_drift/);
+  const altered = await fixture(t);
+  await writeFile(join(altered.source, scriptPath), "untrusted modified runner\n");
+  await assert.rejects(runBehaviorTests(altered.root, altered.name), /managed_script/);
+  const linked = await fixture(t);
+  await symlink(
+    linked.source,
+    join(linked.root, "src/linked"),
+    process.platform === "win32" ? "junction" : "dir",
+  );
+  linked.input.products[0] = {
+    path: `src/linked/${scriptPath}`,
+    sha256: sha(await readFile(join(linked.source, scriptPath))),
+  };
+  await writeFile(join(linked.root, linked.name), JSON.stringify(linked.input));
+  await assert.rejects(runBehaviorTests(linked.root, linked.name), /link/);
+});
+
+test("rejects incomplete or duplicate TAP summaries rather than accepting process exit alone", () => {
+  assert.throws(() => parseTap("node version v24.19.0\n"), /summary/);
+  const summary = "# tests 1\n# pass 1\n# fail 0\n# cancelled 0\n# skipped 0\n# todo 0\n";
+  assert.throws(() => parseTap(summary + "# tests 1\n"), /ambiguous/);
+});

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/SKILL.md

@@ -19,6 +19,39 @@ description: Auditar e reparar telemetria ausente de Runs e tarefas ZAIP usando
    Aplicar somente após confirmação humana explícita com `--apply --deduplicate`. O modo preserva o evento original, insere uma supersessão indisponível antes de `run.finished` e protege o Run corrigido contra o backfill geral posterior.
 8. Somente com autorização humana explícita para aproximação, executar primeiro o diagnóstico `node .agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-local-telemetry.mjs --approximate`. O score combina distância entre data/hora/minuto/segundo de criação e 35% da diferença de duração. Aplicar com `--apply --approximate`; persistir esses vínculos como `legacy_inferred`.
 
+## Pares históricos revisados no mantenedor
+
+Uma chave repetida sozinha não prova duplicação: pode abranger medições diferentes.
+Quando a ordenação antiga não identifica o proprietário, use somente um plano causal
+revisado: `--deduplicate --deduplicate-plan plano.json --run DROP[,DROP]`, primeiro
+sem `--apply`. Não selecione os keepers como drops. Esse modo exige os adaptadores
+oficiais compilados `packages/core/dist`, `packages/decisions/dist` e `packages/lifecycle-manifests/dist` para
+aplicação sob o lock canônico; ausência bloqueia, sem lock alternativo.
+
+O plano tem `schema_version: 1` e `pairs` (máximo 100), cada par com
+`keep_run_id`, `keep_event_id`, `keep_sha256`, `drop_run_id`, `drop_event_id`,
+`drop_sha256`, `drop_semantic_sha256` e `reason`. O hash semântico usa
+`semanticRunHash` do módulo `reconcile-telemetry-reviewed-pairs.mjs`; só ignora
+renumeração de sequência, não conteúdo. Preserve cópias dos arquivos antes de aplicar.
+
+Exija proprietário terminal com turno observado e medição original correspondente;
+o drop deve ser terminal, sem turno, com base `run_finalize` indisponível preenchida
+retroativamente. Tokens, modelo, provider e instante da fonte devem coincidir.
+Prefixo absoluto local/relativo pode variar; sufixos `@RUN` não são descartados.
+Campos opcionais conhecidos conflitantes bloqueiam. Diferenças monetárias só admitem
+até 0,00001 por moeda e centavos iguais; preços originais não são reescritos.
+O modo revalida hashes sob lock canônico e locks oficiais `.lock` do keeper/drop,
+adquiridos em ordem estável, antes da escrita. Lock ocupado bloqueia sem retry nem
+remoção de lock alheio. Rejeita outros reparos combinados.
+Após aplicar, execute replay do mesmo plano: zero novas correções, hashes e eventos
+originais preservados. Divergência ou ausência de prova permanece sem alteração.
+Antes de persistir, o fold canônico valida a sequência completa. Uma cauda contendo
+somente `retrospective_local_remeasurement` com `retrospective_correction: true`
+é normalizada como no append retrospectivo oficial: eventos históricos, correção,
+encerramento. O replay reconstrói a ordem original pelo hash revisado. Uma correção
+já presente fora dessa ordem pode ser normalizada pelo mesmo plano, sem criar
+outro evento nem alterar seu conteúdo; guarde também a versão anterior à recuperação.
+
 ## Normalizar identidade de agentes
 
 Quando o dashboard exibir agentes fora de `.agents/config/agents/catalog.yaml`, execute primeiro o diagnóstico:

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

@@ -1,5 +1,6 @@
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { applyDuplicateAssignments } from "./reconcile-telemetry-deduplicate-apply.mjs";
 import {
   applyExplicitTurnRecovery,
   normalizeExplicitTurnRecoverySchema,
@@ -30,6 +31,7 @@ import {
   remeasureSelectedRuns,
   timingEnrichmentRunIds,
 } from "./reconcile-telemetry-remeasurement.mjs";
+import { reviewedDuplicateAssignments } from "./reconcile-telemetry-reviewed-pairs.mjs";
 import { reconcileGenericModelIdentities } from "./source-size-telemetry/model-identity-reconciliation.mjs";
 
 const workspace = resolve(process.cwd());
@@ -37,9 +39,18 @@ const apply = process.argv.includes("--apply");
 const approximate = process.argv.includes("--approximate");
 const reprice = process.argv.includes("--reprice");
 const deduplicate = process.argv.includes("--deduplicate");
+const reviewedPlanIndex = process.argv.indexOf("--deduplicate-plan");
+const reviewedPlanPath = reviewedPlanIndex < 0 ? null : process.argv[reviewedPlanIndex + 1];
+if (
+  reviewedPlanIndex >= 0 &&
+  (!reviewedPlanPath || reviewedPlanPath.startsWith("--") || !deduplicate)
+)
+  throw new Error("--deduplicate-plan requires a plan file and --deduplicate");
 const remeasure = process.argv.includes("--remeasure");
 const timingOnly = process.argv.includes("--timing-only");
 const explicitRecovery = process.argv.includes("--explicit-turn-recovery");
+if (reviewedPlanPath && (approximate || reprice || remeasure || timingOnly || explicitRecovery))
+  throw new Error("--deduplicate-plan cannot be combined with other repair modes");
 if (timingOnly && !remeasure) {
   throw new Error("--timing-only requires --remeasure");
 }
@@ -195,10 +206,9 @@ for (const file of runFiles) {
   if (started) runs.push({ file, records, started, usage, measured, deduplicated, nativeMeasured });
 }
 
-const allSegments = await loadSegments(
-  workspace,
-  selectedSessionFiles.length === 0 ? null : selectedSessionFiles,
-);
+const allSegments = deduplicate
+  ? []
+  : await loadSegments(workspace, selectedSessionFiles.length === 0 ? null : selectedSessionFiles);
 let explicitSchemaNormalized = false;
 if (apply && explicitRecovery) {
   const run = runs.find((candidate) => candidate.started.run_id === [...selectedRunIds][0]);
@@ -382,65 +392,31 @@ const selectedAliasReviewGroups =
     : 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)),
-);
+const reviewedPlanInput = reviewedPlanPath
+  ? JSON.parse(await readFile(reviewedPlanPath, "utf8"))
+  : null;
+const reviewedPlan = reviewedPlanInput
+  ? await reviewedDuplicateAssignments(reviewedPlanInput, runs, selectedRunIds)
+  : null;
+const duplicateAssignments =
+  reviewedPlan?.assignments ??
+  selectedDuplicateGroups.flatMap((group) =>
+    group
+      .slice(1)
+      .filter(({ run }) => selectedRunIds.size === 0 || selectedRunIds.has(run.started.run_id)),
+  );
 let deduplicatedEvents = 0;
+let reorderedCorrections = 0;
 if (apply && deduplicate) {
-  for (const { run, usage } of duplicateAssignments) {
-    const finish = run.records.find((record) => recordType(record) === "run.finished");
-    const correctionIndex =
-      run.usage.filter((event) => event.activity_kind === "duplicate_segment_reconciliation")
-        .length + 1;
-    const correction = {
-      schema_version: 2,
-      event_id: `${run.started.run_id}:deduplicate:${String(correctionIndex).padStart(6, "0")}`,
-      run_id: run.started.run_id,
-      sequence: 0,
-      occurred_at: finish
-        ? new Date(Date.parse(recordOccurredAt(finish)) - 1).toISOString()
-        : new Date().toISOString(),
-      type: "usage.recorded",
-      phase: usage.phase ?? run.started.phase,
-      activity_kind: "duplicate_segment_reconciliation",
-      classification_source: "current_context",
-      tokens: {
-        input: null,
-        cached_input: null,
-        cache_write_input: null,
-        output: null,
-        reasoning: null,
-        total: null,
-        source: "unavailable",
-      },
-      cost: { usd: null, brl: null, fx_rate: null },
-      provider: usage.provider ?? run.started.provider ?? null,
-      model: usage.model ?? run.started.model ?? "unknown",
-      source_segment_key: usage.source_segment_key,
-      supersedes_event_id: usage.event_id,
-      ...(usage.source_occurred_at === null
-        ? {}
-        : { source_occurred_at: usage.source_occurred_at }),
-      ...(usage.runtime === undefined ? {} : { runtime: usage.runtime }),
-    };
-    const finishIndex = run.records.findIndex((record) => recordType(record) === "run.finished");
-    const insertAt = finishIndex < 0 ? run.records.length : finishIndex;
-    const updated = [
-      ...run.records.slice(0, insertAt),
-      correction,
-      ...run.records.slice(insertAt),
-    ].map((record, index) => withSequence(record, index + 1));
-    const temporary = `${run.file}.deduplicate.tmp`;
-    await writeFile(
-      temporary,
-      `${updated.map((record) => JSON.stringify(record)).join("\n")}\n`,
-      "utf8",
-    );
-    await rename(temporary, run.file);
-    deduplicatedEvents += 1;
-  }
+  deduplicatedEvents = await applyDuplicateAssignments({
+    workspace,
+    runs,
+    selectedRunIds,
+    assignments: duplicateAssignments,
+    reviewedPlan: reviewedPlanInput,
+  });
+  reorderedCorrections = duplicateAssignments.filter((a) => a.correction).length;
+  deduplicatedEvents -= reorderedCorrections;
 }
 
 let candidates = [];
@@ -777,13 +753,17 @@ console.log(
       canonical_alias_review_groups: aliasReviewGroups.length,
       selected_duplicate_segment_groups: selectedDuplicateGroups.length,
       selected_canonical_alias_review_groups: selectedAliasReviewGroups.length,
-      selected_duplicate_segment_impact: duplicateUsageImpact(duplicateAssignments),
+      selected_duplicate_segment_impact: duplicateUsageImpact(
+        duplicateAssignments.filter((a) => !a.correction),
+      ),
       duplicate_segment_assignments: duplicateAssignments.length,
       duplicate_segment_run_ids: duplicateGroups.map((group) =>
         group.map(({ run }) => run.started.run_id),
       ),
       deduplicated_runs_excluded_from_backfill: runs.filter((run) => run.deduplicated).length,
       deduplicated_events: deduplicatedEvents,
+      reordered_corrections: reorderedCorrections,
+      reviewed_pairs_replayed: reviewedPlan?.replayed ?? [],
       repriced_runs: repricedRuns,
       repriced_events: repricedEvents,
       model_identity_corrections: modelIdentityCorrections,

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

@@ -0,0 +1,115 @@
+import {
+  aggregate,
+  canonicalSegmentKey,
+  pricingFor,
+  recordType,
+} from "./reconcile-telemetry-lib.mjs";
+
+const fields = ["input", "cached_input", "output", "reasoning", "total", "cache_write_input"];
+function callView(record) {
+  if (Array.isArray(record) ? record[1] !== "c" : recordType(record) !== "model.call.observed")
+    return null;
+  if (!Array.isArray(record)) return record;
+  const t = record[8];
+  return {
+    call_id: record[5],
+    tokens: {
+      input: t[0],
+      cached_input: t[1],
+      output: t[2],
+      reasoning: t[3],
+      total: t[4],
+      cache_write_input: t[6] ?? null,
+    },
+    cost: { usd: record[9][0], brl: record[9][1] },
+    model: record[11],
+    source_call_key: record[12],
+    source_occurred_at: record[13],
+  };
+}
+const equal = (a, b) => fields.every((key) => a[key] === b[key]);
+const sum = (rows, key) =>
+  rows.every((row) => Number.isFinite(row[key])) ? rows.reduce((n, row) => n + row[key], 0) : null;
+
+/** Bound a native financial correction to the exact calls already included in its receipt. */
+export async function nativeWindowCorrection({ records, segment, superseded, workspace }) {
+  const calls = records.map(callView).filter(Boolean);
+  if (calls.length === 0) return null;
+  const block = (reason) => ({ eligible: false, reason });
+  if (new Set(calls.map((call) => call.call_id)).size !== calls.length)
+    return block("native-call-history-ambiguous");
+  const key = canonicalSegmentKey(segment.key);
+  if (
+    calls.some(
+      (call) =>
+        !call.source_occurred_at ||
+        canonicalSegmentKey(call.source_call_key ?? "").replace(/:loop:\d+$/, "") !== key,
+    )
+  )
+    return block("native-call-segment-mismatch");
+  const timestamps = new Set(calls.map((call) => call.source_occurred_at));
+  if (timestamps.size !== calls.length) return block("native-call-timestamps-ambiguous");
+  const matched = segment.usage.filter((usage) => timestamps.has(usage.source_timestamp));
+  if (matched.length !== calls.length) return block("native-call-source-incomplete");
+  const source = new Map(
+    matched.map((usage) => [usage.source_timestamp, aggregate({ usage: [usage] })]),
+  );
+  const changed = calls.filter((call) => !equal(call.tokens, source.get(call.source_occurred_at)));
+  // This recovery is deliberately limited to an inherited first cumulative receipt.
+  if (
+    changed.length !== 1 ||
+    changed[0] !== calls[0] ||
+    matched[0] !== segment.usage[0] ||
+    !(changed[0].tokens.total > source.get(changed[0].source_occurred_at).total)
+  )
+    return block("native-call-change-not-inherited-baseline");
+  const tokens = aggregate({ usage: matched });
+  const original = Object.fromEntries(
+    fields.map((field) => [
+      field,
+      sum(
+        calls.map((call) => call.tokens),
+        field,
+      ),
+    ]),
+  );
+  if (!equal(superseded.tokens, original) && !equal(superseded.tokens, tokens))
+    return block("native-call-aggregate-mismatch");
+  const first = calls[0];
+  if (
+    !matched[0].inherited_cumulative ||
+    !equal(first.tokens, aggregate({ usage: [matched[0].inherited_cumulative] }))
+  )
+    return block("native-inherited-baseline-unproven");
+  const originalPrice = await pricingFor(workspace, first.model, first.tokens);
+  if (
+    ["usd", "brl"].some(
+      (currency) =>
+        !Number.isFinite(first.cost[currency]) ||
+        !Number.isFinite(originalPrice[currency]) ||
+        Math.abs(first.cost[currency] - originalPrice[currency]) > 0.00001,
+    )
+  )
+    return block("native-call-pricing-changed");
+  const replacement = await pricingFor(
+    workspace,
+    first.model,
+    source.get(first.source_occurred_at),
+  );
+  const cost = Object.fromEntries(
+    ["usd", "brl"].map((currency) => [
+      currency,
+      sum([replacement, ...calls.slice(1).map((call) => call.cost)], currency),
+    ]),
+  );
+  if (!Number.isFinite(cost.usd) || !Number.isFinite(cost.brl))
+    return block("native-call-pricing-unavailable");
+  return {
+    eligible: true,
+    tokens,
+    cost,
+    matched_calls: calls.length,
+    corrected_call_id: first.call_id,
+    excluded_later_source_calls: segment.usage.length - matched.length,
+  };
+}

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

@@ -0,0 +1,123 @@
+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 test from "node:test";
+import { nativeWindowCorrection } from "./reconcile-native-window.mjs";
+import { aggregate } from "./reconcile-telemetry-lib.mjs";
+
+const snapshot = (input, source_timestamp) => ({
+  input_tokens: input,
+  cached_input_tokens: 0,
+  cache_write_input_tokens: 0,
+  output_tokens: 0,
+  reasoning_output_tokens: 0,
+  total_tokens: input,
+  source_timestamp,
+});
+async function fixture(t) {
+  const workspace = await mkdtemp(join(tmpdir(), "zaip-native-window-"));
+  t.after(() => rm(workspace, { recursive: true, force: true }));
+  await mkdir(join(workspace, ".agents/config/pricing/fx"), { recursive: true });
+  await writeFile(
+    join(workspace, ".agents/config/pricing/models.json"),
+    JSON.stringify({
+      models: [
+        {
+          id: "fixture",
+          input_per_million_usd: 1,
+          cached_input_per_million_usd: 0,
+          output_per_million_usd: 1,
+        },
+      ],
+    }),
+  );
+  await writeFile(
+    join(workspace, ".agents/config/pricing/fx/fixture.json"),
+    JSON.stringify({ rate: 5 }),
+  );
+  const before = [snapshot(1_000_000, "t1"), snapshot(100_000, "t2")];
+  const calls = before.map((usage, i) => ({
+    type: "model.call.observed",
+    call_id: `MCALL-${i}`,
+    tokens: aggregate({ usage: [usage] }),
+    model: "fixture",
+    source_call_key: `sessions/fixture#1:loop:${i + 1}`,
+    source_occurred_at: usage.source_timestamp,
+    cost: { usd: usage.total_tokens / 1_000_000, brl: usage.total_tokens / 200_000 },
+  }));
+  return {
+    workspace,
+    records: calls,
+    segment: {
+      key: "sessions/fixture#1",
+      usage: [
+        { ...snapshot(200_000, "t1"), inherited_cumulative: before[0] },
+        before[1],
+        snapshot(300_000, "later"),
+      ],
+    },
+    superseded: { tokens: aggregate({ usage: before }) },
+  };
+}
+
+test("changes only a source-proven inherited first receipt and excludes later calls; replay is stable", async (t) => {
+  const f = await fixture(t);
+  const original = JSON.stringify(f.records);
+  const proof = await nativeWindowCorrection(f);
+  assert.equal(proof.eligible, true);
+  assert.equal(proof.tokens.total, 300_000);
+  assert.deepEqual(proof.cost, { usd: 0.30000000000000004, brl: 1.5 });
+  assert.equal(proof.excluded_later_source_calls, 1);
+  assert.equal(proof.matched_calls, 2);
+  assert.deepEqual(
+    await nativeWindowCorrection({ ...f, superseded: { tokens: proof.tokens } }),
+    proof,
+  );
+  assert.equal(JSON.stringify(f.records), original);
+});
+
+test("refuses missing source, changed price, unrelated aggregate and unproven inherited baseline", async (t) => {
+  for (const change of [
+    (f) => {
+      f.segment.usage[0].inherited_cumulative = null;
+    },
+    (f) => {
+      f.records[0].cost.usd = 2;
+    },
+    (f) => {
+      f.superseded.tokens.total = 7;
+    },
+    (f) => {
+      f.segment.usage.splice(1, 1);
+    },
+    (f) => {
+      f.records[1].source_occurred_at = "t1";
+    },
+  ]) {
+    const f = await fixture(t);
+    change(f);
+    assert.equal((await nativeWindowCorrection(f)).eligible, false);
+  }
+});
+
+test("recognizes the native compact representation instead of remeasuring the whole segment", async (t) => {
+  const f = await fixture(t);
+  f.records = f.records.map((c, i) => [
+    3,
+    "c",
+    `event-${i}`,
+    i + 1,
+    "recorded",
+    c.call_id,
+    "AINV",
+    "partial",
+    [c.tokens.input, 0, 0, 0, c.tokens.total, "provider_reported", 0],
+    [c.cost.usd, c.cost.brl, 5],
+    "provider",
+    c.model,
+    c.source_call_key,
+    c.source_occurred_at,
+  ]);
+  assert.equal((await nativeWindowCorrection(f)).tokens.total, 300_000);
+});

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

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, test } from "node:test";
+import {
+  normalizeRetrospectiveTiming,
+  optionalSourceTiming,
+} from "./reconcile-telemetry-remeasurement.mjs";
+
+const roots = [];
+after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
+test("omits unknown optional timestamps and normalizes only its own retrospective correction idempotently", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zaip-timing-optionals-"));
+  roots.push(root);
+  const file = join(root, "run.jsonl");
+  const historical = { type: "usage.recorded", event_id: "old", source_finished_at: null };
+  const correction = {
+    ...historical,
+    event_id: "repair",
+    retrospective_correction: true,
+    activity_kind: "retrospective_local_remeasurement",
+  };
+  const records = [historical, correction];
+  await writeFile(file, `${records.map(JSON.stringify).join("\n")}\n`);
+  assert.deepEqual(
+    optionalSourceTiming({ source_started_at: "2026-10-20T00:00:00Z", source_finished_at: null }),
+    { source_started_at: "2026-10-20T00:00:00Z" },
+  );
+  assert.equal(await normalizeRetrospectiveTiming(file, records), true);
+  assert.equal(records[0].source_finished_at, null);
+  assert.equal("source_finished_at" in records[1], false);
+  assert.equal(await normalizeRetrospectiveTiming(file, records), false);
+});