@zaip-ai/cli 6.3.0 → 7.5.0

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-reviewed-pairs-fixture.mjs

@@ -0,0 +1,130 @@
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { semanticRunHash } from "./reconcile-telemetry-reviewed-pairs.mjs";
+
+export const tokens = {
+  input: 900,
+  cached_input: 800,
+  cache_write_input: null,
+  output: 100,
+  reasoning: 20,
+  total: 1000,
+  source: "provider_reported",
+};
+export const source = "sessions/2026/07/01/rollout-test.jsonl#1";
+export async function fixture(t, change = () => {}) {
+  const root = await mkdtemp(join(tmpdir(), "zaip-reviewed-pair-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  await mkdir(join(root, ".agents/records/runs/2026/07"), { recursive: true });
+  const runs = ["KEEP", "DROP"].map((name, i) => {
+    const id = `RUN-2026-07-01-${name}`,
+      original = {
+        schema_version: 2,
+        type: "usage.recorded",
+        event_id: `${id}:u`,
+        run_id: id,
+        sequence: 2,
+        occurred_at: "2026-07-01T00:00:02.000Z",
+        phase: "execution",
+        activity_kind: i ? "run_finalize" : "implementation",
+        classification_source: "current_context",
+        tokens: i
+          ? Object.fromEntries(
+              Object.keys(tokens).map((k) => [k, k === "source" ? "unavailable" : null]),
+            )
+          : { ...tokens },
+        cost: i ? { usd: null, brl: null } : { usd: 1, brl: 5.45 },
+        provider: "openai",
+        model: "model-test",
+        source_segment_key: i ? null : source,
+        supersedes_event_id: null,
+        source_occurred_at: "2026-07-01T00:00:02.000Z",
+      };
+    const start = {
+      schema_version: 2,
+      type: "run.started",
+      event_id: `id:s`,
+      run_id: id,
+      sequence: 1,
+      occurred_at: "2026-07-01T00:00:00.000Z",
+      phase: "execution",
+      attribution_status: "attributed",
+      entrypoint: "task",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "test",
+      agent: "test",
+      provider: "openai",
+      model: "model-test",
+      conversation_id: "CONV-TEST",
+      execution_id: "EXEC-TEST",
+      task_id: "TASK-TEST",
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+      client_turn_id: i ? null : "019f7b1b-133f-7e03-9036-2fb7ad690616",
+    };
+    const usage = i
+      ? [
+          original,
+          {
+            ...structuredClone(original),
+            event_id: `${id}:retro`,
+            sequence: 3,
+            activity_kind: "retrospective_local_reconciliation",
+            tokens: { ...tokens },
+            cost: { usd: 1, brl: 5.4500004 },
+            source_segment_key: join(homedir(), ".codex", source),
+            supersedes_event_id: original.event_id,
+          },
+        ]
+      : [original];
+    return {
+      file: join(root, `.agents/records/runs/2026/07/${id}.jsonl`),
+      started: start,
+      usage,
+      records: [
+        start,
+        ...usage,
+        {
+          schema_version: 2,
+          type: "run.finished",
+          event_id: `${id}:f`,
+          sequence: usage.length + 2,
+          run_id: id,
+          phase: "execution",
+          status: "completed",
+          occurred_at: "2026-07-01T00:00:03.000Z",
+        },
+      ],
+    };
+  });
+  change(runs);
+  const hashes = [];
+  for (const r of runs) {
+    const bytes = r.records.map(JSON.stringify).join("\n") + "\n";
+    await writeFile(r.file, bytes);
+    hashes.push(createHash("sha256").update(bytes).digest("hex"));
+  }
+  const pair = {
+    keep_run_id: runs[0].started.run_id,
+    keep_event_id: runs[0].usage.at(-1).event_id,
+    keep_sha256: hashes[0],
+    drop_run_id: runs[1].started.run_id,
+    drop_event_id: runs[1].usage.at(-1).event_id,
+    drop_sha256: hashes[1],
+    drop_semantic_sha256: semanticRunHash(runs[1].records),
+    reason: "Explicit fixture causal review",
+  };
+  return {
+    root,
+    runs,
+    plan: { schema_version: 1, pairs: [pair] },
+    selected: new Set([pair.drop_run_id]),
+  };
+}

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

@@ -0,0 +1,106 @@
+import { rename, writeFile } from "node:fs/promises";
+import {
+  recordOccurredAt,
+  recordType,
+  usageView,
+  withSequence,
+} from "./reconcile-telemetry-lib.mjs";
+import {
+  reviewedCorrectionOrder,
+  validateReviewedCanonicalOrder,
+} from "./reconcile-telemetry-reviewed-order.mjs";
+import {
+  assertReviewedFilesUnchanged,
+  reviewedDuplicateAssignments,
+  withReviewedPairLocks,
+  withReviewedRepairLock,
+} from "./reconcile-telemetry-reviewed-pairs.mjs";
+
+export async function applyDuplicateAssignments({
+  workspace,
+  runs,
+  selectedRunIds,
+  assignments,
+  reviewedPlan,
+}) {
+  const apply = async () => {
+    if (reviewedPlan)
+      assignments = (await reviewedDuplicateAssignments(reviewedPlan, runs, selectedRunIds))
+        .assignments;
+    let count = 0;
+    for (const {
+      run,
+      usage,
+      correction: existingCorrection,
+      original,
+      repair_sha256,
+    } of assignments) {
+      const pair = reviewedPlan?.pairs.find((p) => p.drop_run_id === run.started.run_id);
+      const writeCorrection = async () => {
+        const finish = run.records.find((r) => recordType(r) === "run.finished");
+        const index =
+          run.usage.filter((u) => u.activity_kind === "duplicate_segment_reconciliation").length +
+          1;
+        const correction = existingCorrection ?? {
+          schema_version: 2,
+          event_id: `${run.started.run_id}:deduplicate:${String(index).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((r) => recordType(r) === "run.finished");
+        const at = finishIndex < 0 ? run.records.length : finishIndex;
+        const updated = reviewedPlan
+          ? reviewedCorrectionOrder(original ?? run.records, correction)
+          : [...run.records.slice(0, at), correction, ...run.records.slice(at)].map((r, i) =>
+              withSequence(r, i + 1),
+            );
+        if (reviewedPlan) {
+          await validateReviewedCanonicalOrder(workspace, updated);
+          await assertReviewedFilesUnchanged(
+            repair_sha256 ? { ...pair, drop_sha256: repair_sha256 } : pair,
+            runs,
+          );
+        }
+        const temporary = `${run.file}.deduplicate.tmp`;
+        await writeFile(temporary, updated.map(JSON.stringify).join("\n") + "\n", {
+          encoding: "utf8",
+          flag: "wx",
+        });
+        await rename(temporary, run.file);
+        // A second correction for the same legacy Run must not overwrite the first.
+        run.records = updated;
+        run.usage = updated.map(usageView).filter(Boolean);
+        count++;
+      };
+      if (pair) await withReviewedPairLocks(pair, runs, writeCorrection);
+      else await writeCorrection();
+    }
+    return count;
+  };
+  return reviewedPlan ? withReviewedRepairLock(workspace, apply) : apply();
+}

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

@@ -1,3 +1,11 @@
+import {
+  cumulativeSnapshotDelta,
+  hasPositiveTokenDelta,
+  tokenSnapshot,
+} from "./reconcile-token-snapshots.mjs";
+
+export { cumulativeSnapshotDelta } from "./reconcile-token-snapshots.mjs";
+
 import { createReadStream } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -454,15 +462,26 @@ export async function loadSegments(workspace, sessionFiles = null) {
         const previous = latestCumulativeUsage;
         if (cumulative !== null) latestCumulativeUsage = cumulative;
         if (!current) continue;
+        const delta = cumulative === null ? null : cumulativeSnapshotDelta(previous, cumulative);
+        const knownDelta = delta !== null && Object.values(delta).some((value) => value !== null);
         const usage =
           cumulative === null
             ? incremental !== null && sameTokenSnapshot(latestIncrementalUsage, incremental)
               ? null
               : incremental
-            : cumulativeSnapshotDelta(previous, cumulative);
+            : knownDelta
+              ? delta
+              : (incremental ?? delta);
         if (cumulative === null && incremental !== null) latestIncrementalUsage = incremental;
-        if (usage !== null && hasPositiveTokenDelta(usage)) {
-          current.usage.push({ ...usage, source_timestamp: record.timestamp ?? null });
+        if (
+          usage !== null &&
+          (hasPositiveTokenDelta(usage) || Object.values(usage).every((value) => value === null))
+        ) {
+          current.usage.push({
+            ...usage,
+            source_timestamp: record.timestamp ?? null,
+            inherited_cumulative: previous === null ? cumulative : null,
+          });
         }
       }
       if (!current) continue;
@@ -534,48 +553,6 @@ export function aggregate(segment) {
   };
 }
 
-function tokenSnapshot(value) {
-  if (typeof value !== "object" || value === null) return null;
-  const finite = (key) => (Number.isFinite(value[key]) && value[key] >= 0 ? value[key] : null);
-  return {
-    input_tokens: finite("input_tokens"),
-    cached_input_tokens: finite("cached_input_tokens"),
-    cache_write_input_tokens: finite("cache_write_input_tokens"),
-    output_tokens: finite("output_tokens"),
-    reasoning_output_tokens: finite("reasoning_output_tokens"),
-    total_tokens: finite("total_tokens"),
-  };
-}
-
-export function cumulativeSnapshotDelta(previous, current) {
-  const delta = (key) => {
-    const value = current[key];
-    if (!Number.isFinite(value)) return null;
-    const baseline = previous?.[key];
-    if (!Number.isFinite(baseline)) return value;
-    return value >= baseline ? value - baseline : value;
-  };
-  return {
-    input_tokens: delta("input_tokens"),
-    cached_input_tokens: delta("cached_input_tokens"),
-    cache_write_input_tokens: delta("cache_write_input_tokens"),
-    output_tokens: delta("output_tokens"),
-    reasoning_output_tokens: delta("reasoning_output_tokens"),
-    total_tokens: delta("total_tokens"),
-  };
-}
-
-function hasPositiveTokenDelta(usage) {
-  return [
-    usage.input_tokens,
-    usage.cached_input_tokens,
-    usage.cache_write_input_tokens,
-    usage.output_tokens,
-    usage.reasoning_output_tokens,
-    usage.total_tokens,
-  ].some((value) => value !== null && value > 0);
-}
-
 export async function pricingFor(workspace, model, tokens) {
   let catalog;
   try {

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

@@ -6,7 +6,6 @@ import { after, test } from "node:test";
 import {
   aggregate,
   canonicalSessionId,
-  cumulativeSnapshotDelta,
   duplicateUsageAssignments,
   duplicateUsageImpact,
   exactCompletedSegment,
@@ -114,29 +113,6 @@ test("normalizes compact and object Run records without changing usage totals",
   );
 });
 
-test("preserves absent, zero, and positive cache-write snapshots through deltas", () => {
-  const snapshot = (input, cached, cacheWrite, output, reasoning) => ({
-    input_tokens: input,
-    cached_input_tokens: cached,
-    cache_write_input_tokens: cacheWrite,
-    output_tokens: output,
-    reasoning_output_tokens: reasoning,
-    total_tokens: input + output,
-  });
-  assert.deepEqual(
-    cumulativeSnapshotDelta(snapshot(100, 80, 0, 20, 5), snapshot(100, 80, 0, 20, 5)),
-    snapshot(0, 0, 0, 0, 0),
-  );
-  assert.deepEqual(
-    cumulativeSnapshotDelta(snapshot(100, 80, 0, 20, 5), snapshot(140, 110, 10, 35, 9)),
-    snapshot(40, 30, 10, 15, 4),
-  );
-  assert.deepEqual(
-    cumulativeSnapshotDelta(snapshot(140, 110, 10, 35, 9), snapshot(12, 8, null, 3, 1)),
-    snapshot(12, 8, null, 3, 1),
-  );
-});
-
 test("deduplicates only consecutive identical last_token_usage fallback snapshots", () => {
   const snapshot = {
     input_tokens: 10,

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

@@ -1,4 +1,5 @@
 import { open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { nativeWindowCorrection } from "./reconcile-native-window.mjs";
 import {
   aggregate,
   exactCompletedSegment,
@@ -29,6 +30,7 @@ export const remeasureSelectedRuns = async ({
       continue;
     }
     const effectiveUsage = usageStatus(run.usage).effective;
+    if (apply) await normalizeRetrospectiveTiming(run.file, run.records);
     const effective = timingOnly
       ? effectiveUsage
       : effectiveUsage.filter(
@@ -70,7 +72,14 @@ export const remeasureSelectedRuns = async ({
       });
       continue;
     }
-    const tokens = aggregate(segment);
+    const native = timingOnly
+      ? null
+      : await nativeWindowCorrection({ records: run.records, segment, superseded, workspace });
+    if (native?.eligible === false) {
+      remeasurement.push({ run_id: runId, ...native });
+      continue;
+    }
+    const tokens = native?.tokens ?? aggregate(segment);
     const unchanged =
       superseded.tokens.input === tokens.input &&
       superseded.tokens.cached_input === tokens.cached_input &&
@@ -78,9 +87,10 @@ export const remeasureSelectedRuns = async ({
       superseded.tokens.output === tokens.output &&
       superseded.tokens.reasoning === tokens.reasoning &&
       superseded.tokens.total === tokens.total;
-    const timingChanged =
-      superseded.source_started_at !== segment.started_at ||
-      superseded.source_finished_at !== segment.finished_at;
+    const timingChanged = native
+      ? false
+      : superseded.source_started_at !== segment.started_at ||
+        superseded.source_finished_at !== segment.finished_at;
     const timingOnlyEligible = timingChanged;
     const item = {
       run_id: runId,
@@ -92,6 +102,7 @@ export const remeasureSelectedRuns = async ({
       supersedes_event_id: superseded.event_id,
       unchanged,
       timing_enrichment: timingChanged,
+      ...(native ? { native_window: native } : {}),
       ...(timingOnly && !timingOnlyEligible ? { reason: "source-timing-already-complete" } : {}),
     };
     remeasurement.push(item);
@@ -102,7 +113,9 @@ export const remeasureSelectedRuns = async ({
     const recordedTokens = timingOnly
       ? superseded.tokens
       : { ...tokens, source: "provider_reported" };
-    const recordedCost = timingOnly ? superseded.cost : await pricingFor(workspace, model, tokens);
+    const recordedCost = timingOnly
+      ? superseded.cost
+      : (native?.cost ?? (await pricingFor(workspace, model, tokens)));
     const sequence = run.records.length + 1;
     const event = {
       schema_version: 2,
@@ -118,12 +131,18 @@ export const remeasureSelectedRuns = async ({
       cost: recordedCost,
       provider: timingOnly ? superseded.provider : (run.started.provider ?? "openai"),
       model: timingOnly ? superseded.model : model,
-      source_segment_key: segment.key,
+      source_segment_key: native ? superseded.source_segment_key : segment.key,
       supersedes_event_id: superseded.event_id,
       retrospective_correction: true,
-      source_occurred_at: segment.finished_at ?? segment.started_at,
-      source_started_at: segment.started_at,
-      source_finished_at: segment.finished_at,
+      ...optionalSourceTiming(
+        native
+          ? superseded
+          : {
+              source_occurred_at: segment.finished_at ?? segment.started_at,
+              source_started_at: segment.started_at,
+              source_finished_at: segment.finished_at,
+            },
+      ),
       runtime: {
         reasoning_effort: timingOnly
           ? (superseded.runtime?.reasoning_effort ?? null)
@@ -225,3 +244,48 @@ export function assertRetrospectiveAppend(
 export function retrospectiveCorrectionOccurredAt(now = () => new Date()) {
   return now().toISOString();
 }
+
+export function optionalSourceTiming(source) {
+  return Object.fromEntries(
+    ["source_occurred_at", "source_started_at", "source_finished_at"]
+      .filter((key) => typeof source[key] === "string")
+      .map((key) => [key, source[key]]),
+  );
+}
+
+/** Repair only absent optional timestamps serialized as null by an earlier remeasurement. */
+export async function normalizeRetrospectiveTiming(file, records) {
+  const updated = records.map((record) => {
+    if (
+      Array.isArray(record) ||
+      record.type !== "usage.recorded" ||
+      record.retrospective_correction !== true ||
+      record.activity_kind !== "retrospective_local_remeasurement"
+    )
+      return record;
+    const copy = { ...record };
+    for (const key of ["source_occurred_at", "source_started_at", "source_finished_at"])
+      if (copy[key] === null) delete copy[key];
+    return copy;
+  });
+  if (JSON.stringify(updated) === JSON.stringify(records)) return false;
+  const lock = `${file}.lock`;
+  const handle = await open(lock, "wx");
+  await handle.close();
+  try {
+    const persisted = jsonLines(await readFile(file, "utf8"));
+    if (JSON.stringify(persisted) !== JSON.stringify(records))
+      throw new Error("Run history changed before optional timing normalization");
+    const temporary = `${file}.remeasure.tmp`;
+    await writeFile(
+      temporary,
+      `${updated.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, file);
+    records.splice(0, records.length, ...updated);
+    return true;
+  } finally {
+    await rm(lock, { force: true });
+  }
+}

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

@@ -0,0 +1,48 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { recordType, usageView, withSequence } from "./reconcile-telemetry-lib.mjs";
+
+const id = (r) => (Array.isArray(r) ? r[2] : r.event_id);
+const allowedTail = (r) => {
+  const u = usageView(r);
+  return (
+    u?.activity_kind === "retrospective_local_remeasurement" && u.retrospective_correction === true
+  );
+};
+
+// Recover the exact original order by its reviewed hash. Only the official
+// retrospective append's terminal relocation is allowed; event bodies stay intact.
+export function reviewedOriginalOrder(records, correction, expectedHash, hash) {
+  const original = records.filter((r) => id(r) !== correction.event_id);
+  if (hash(original) === expectedHash) return original;
+  const finish = original.at(-1);
+  if (recordType(finish) === "run.finished") {
+    const body = original.slice(0, -1);
+    for (let index = body.length - 1; index > 0 && allowedTail(body[index]); index--) {
+      const candidate = [...body.slice(0, index), finish, ...body.slice(index)];
+      if (hash(candidate) === expectedHash) return candidate;
+    }
+  }
+  throw new Error("Reviewed deduplication refused: replay source drift");
+}
+
+export function reviewedCorrectionOrder(original, correction) {
+  const at = original.findIndex((r) => recordType(r) === "run.finished");
+  if (
+    at < 0 ||
+    original.filter((r) => recordType(r) === "run.finished").length !== 1 ||
+    original.slice(at + 1).some((r) => !allowedTail(r))
+  )
+    throw new Error("Reviewed deduplication refused: unsupported terminal tail");
+  // Same normalization as appendRetrospectiveUsage. No event is discarded.
+  return [...original.slice(0, at), ...original.slice(at + 1), correction, original[at]].map(
+    (r, i) => withSequence(r, i + 1),
+  );
+}
+
+export async function validateReviewedCanonicalOrder(workspace, records) {
+  const { foldRunV2Records, parseRunV2JsonLines } = await import(
+    pathToFileURL(resolve(workspace, "packages/decisions/dist/index.js")).href
+  );
+  return foldRunV2Records(parseRunV2JsonLines(records.map(JSON.stringify).join("\n") + "\n"));
+}