@zaip-ai/cli 0.1.0 → 1.0.1

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

@@ -0,0 +1,698 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import {
+  aggregate,
+  duplicateUsageAssignments,
+  exactCompletedSegment,
+  filesUnder,
+  jsonLines,
+  loadSegments,
+  pricingFor,
+  recordOccurredAt,
+  recordSequence,
+  recordType,
+  sameCost,
+  usageStatus,
+  usageView,
+  withSequence,
+} from "./reconcile-telemetry-lib.mjs";
+
+const workspace = resolve(process.cwd());
+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 applyBackfill = apply && !deduplicate;
+
+const runFiles = await filesUnder(join(workspace, ".agents", "records", "runs"), ".jsonl");
+const runs = [];
+const usedKeys = new Set();
+let danglingSupersessionRepairs = 0;
+for (const file of runFiles) {
+  let records = jsonLines(await readFile(file, "utf8"));
+  const finishedRecord = records.find((record) => recordType(record) === "run.finished");
+  const canonicalCorrectionTime = finishedRecord
+    ? new Date(Date.parse(recordOccurredAt(finishedRecord)) - 1).toISOString()
+    : null;
+  const staleCorrectionTime =
+    canonicalCorrectionTime !== null &&
+    records.some(
+      (record) =>
+        usageView(record)?.activity_kind === "retrospective_local_reconciliation" &&
+        recordOccurredAt(record) !== canonicalCorrectionTime,
+    );
+  if (applyBackfill && staleCorrectionTime) {
+    records = records.map((record) =>
+      usageView(record)?.activity_kind === "retrospective_local_reconciliation"
+        ? { ...record, occurred_at: canonicalCorrectionTime }
+        : record,
+    );
+  }
+  const nativeMeasured = records.some((record) => {
+    const usage = usageView(record);
+    return (
+      usage &&
+      usage.activity_kind !== "retrospective_local_reconciliation" &&
+      usage.tokens.input !== null &&
+      usage.tokens.output !== null
+    );
+  });
+  const referencedUsageIds = new Set(
+    records
+      .map(usageView)
+      .filter(Boolean)
+      .map((usage) => usage.supersedes_event_id)
+      .filter(Boolean),
+  );
+  if (applyBackfill && nativeMeasured)
+    records = records.filter((record) => {
+      const usage = usageView(record);
+      return (
+        usage?.activity_kind !== "retrospective_local_reconciliation" ||
+        referencedUsageIds.has(usage.event_id)
+      );
+    });
+  const priorUsageIds = [];
+  let repairedDangling = false;
+  records = records.map((record) => {
+    const usage = usageView(record);
+    if (!usage) return record;
+    let next = record;
+    if (usage.supersedes_event_id !== null && !priorUsageIds.includes(usage.supersedes_event_id)) {
+      danglingSupersessionRepairs += 1;
+      if (applyBackfill) {
+        repairedDangling = true;
+        const replacement = priorUsageIds.at(-1) ?? null;
+        next = Array.isArray(record)
+          ? (() => {
+              const copy = [...record];
+              copy[13] = replacement;
+              return copy;
+            })()
+          : { ...record, supersedes_event_id: replacement };
+      }
+    }
+    priorUsageIds.push(usage.event_id);
+    return next;
+  });
+  if (applyBackfill && repairedDangling) {
+    const temporary = `${file}.supersession.tmp`;
+    await writeFile(
+      temporary,
+      `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, file);
+  }
+  const finishIndex = records.findIndex((record) => recordType(record) === "run.finished");
+  const misplaced = records.filter(
+    (record, index) =>
+      usageView(record)?.activity_kind === "retrospective_local_reconciliation" &&
+      index > finishIndex &&
+      finishIndex >= 0,
+  );
+  if (applyBackfill && (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)];
+    const temporary = `${file}.reconcile.tmp`;
+    await writeFile(
+      temporary,
+      `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, file);
+  }
+  const hasCorrection = records.some(
+    (record) => usageView(record)?.activity_kind === "retrospective_local_reconciliation",
+  );
+  if (
+    applyBackfill &&
+    (hasCorrection || nativeMeasured) &&
+    records.some((record, index) => recordSequence(record) !== index + 1)
+  ) {
+    records = records.map((record, index) => withSequence(record, index + 1));
+    const temporary = `${file}.reconcile.tmp`;
+    await writeFile(
+      temporary,
+      `${records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    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)
+      usedKeys.add(event.source_segment_key);
+  const { measured, deduplicated } = usageStatus(usage);
+  if (started) runs.push({ file, records, started, usage, measured, deduplicated });
+}
+
+const allSegments = await loadSegments(workspace);
+const unfinished = runs.filter(
+  (run) => !run.records.some((record) => recordType(record) === "run.finished"),
+);
+const unfinishedMatches = unfinished.map((run) => ({
+  run,
+  ...exactCompletedSegment(run.started, allSegments),
+}));
+const finishEligible = unfinishedMatches.filter(({ segment }) => segment !== null);
+const finishAmbiguous = unfinishedMatches.filter(({ ambiguous }) => ambiguous);
+if (applyBackfill) {
+  for (const { run, segment } of finishEligible) {
+    const sequence = Math.max(...run.records.map((record) => recordSequence(record) ?? 0)) + 1;
+    const finished = {
+      schema_version: 2,
+      event_id: `${run.started.run_id}:reconcile-finish:${String(sequence).padStart(6, "0")}`,
+      run_id: run.started.run_id,
+      sequence,
+      occurred_at: segment.finished_at,
+      type: "run.finished",
+      phase: run.started.phase,
+      status: "completed",
+    };
+    run.records = [...run.records, finished].map((record, index) =>
+      withSequence(record, index + 1),
+    );
+    const temporary = `${run.file}.finish.tmp`;
+    await writeFile(
+      temporary,
+      `${run.records.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, run.file);
+  }
+}
+const missing = runs.filter(
+  (run) =>
+    !run.measured &&
+    !run.deduplicated &&
+    run.records.some((record) => recordType(record) === "run.finished"),
+);
+const segments = allSegments.filter((segment) => !usedKeys.has(segment.key));
+
+let repricedEvents = 0;
+let repricedRuns = 0;
+if (reprice) {
+  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 = [];
+    for (const usage of effective) {
+      if (usage.tokens.input === null || usage.tokens.output === null) continue;
+      const expected = await pricingFor(workspace, usage.model ?? run.started.model, usage.tokens);
+      if (expected.usd === null || sameCost(usage.cost, expected)) continue;
+      corrections.push({ usage, expected });
+    }
+    if (corrections.length === 0) continue;
+    repricedRuns += 1;
+    repricedEvents += corrections.length;
+    if (!applyBackfill) continue;
+
+    const correctionByTarget = new Map(corrections.map((item) => [item.usage.event_id, item]));
+    const updated = [];
+    let correctionIndex = run.usage.filter(
+      (usage) => usage.activity_kind === "pricing_catalog_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;
+      updated.push({
+        schema_version: 2,
+        event_id: `${run.started.run_id}:reprice:${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: "pricing_catalog_reconciliation",
+        classification_source: original.classification_source ?? "current_context",
+        tokens: original.tokens,
+        cost: correction.expected,
+        provider: original.provider ?? run.started.provider,
+        model: original.model ?? run.started.model,
+        source_segment_key: original.source_segment_key,
+        supersedes_event_id: original.event_id,
+        ...(original.source_occurred_at === null
+          ? {}
+          : { source_occurred_at: original.source_occurred_at }),
+        ...(original.context_stats === undefined ? {} : { context_stats: original.context_stats }),
+        ...(original.runtime === undefined ? {} : { runtime: original.runtime }),
+      });
+    }
+    const resequenced = updated.map((record, index) => withSequence(record, index + 1));
+    const temporary = `${run.file}.reprice.tmp`;
+    await writeFile(
+      temporary,
+      `${resequenced.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, run.file);
+  }
+}
+
+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 duplicateGroups = duplicateUsageAssignments(runs);
+const duplicateAssignments = duplicateGroups.flatMap((group) => group.slice(1));
+let deduplicatedEvents = 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,
+        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;
+  }
+}
+
+let candidates = [];
+for (const segment of segments) {
+  const exactTurn = missing.filter(
+    (run) => run.started.client_turn_id && run.started.client_turn_id === segment.turn_id,
+  );
+  for (const run of exactTurn) {
+    const runStart = Date.parse(run.started.occurred_at);
+    const finished = run.records.find((record) => recordType(record) === "run.finished");
+    const runFinish = finished ? Date.parse(recordOccurredAt(finished)) : Date.now();
+    const scopedUsage = segment.usage.filter((usage) => {
+      const timestamp = Date.parse(usage.source_timestamp ?? "");
+      return Number.isFinite(timestamp) && timestamp >= runStart && timestamp <= runFinish;
+    });
+    if (scopedUsage.length > 0)
+      candidates.push({
+        run,
+        segment: {
+          ...segment,
+          key: `${segment.key}@${run.started.run_id}`,
+          usage: scopedUsage,
+        },
+        confidence: "exact_client_turn_time_slice",
+      });
+  }
+  const legacyMissing = missing.filter((run) => !run.started.client_turn_id);
+  const exact =
+    exactTurn.length === 0
+      ? legacyMissing.filter((run) => segment.raw.includes(run.started.run_id))
+      : [];
+  if (exact.length === 1) candidates.push({ run: exact[0], segment, confidence: "exact_run_id" });
+  if (exactTurn.length === 0 && exact.length === 0) {
+    const taskMatches = legacyMissing.filter(
+      (run) => run.started.task_id && segment.raw.includes(run.started.task_id),
+    );
+    if (taskMatches.length === 1)
+      candidates.push({ run: taskMatches[0], segment, confidence: "exact_task_id" });
+    else if (taskMatches.length > 1 && segment.started_at && segment.finished_at) {
+      const start = Date.parse(segment.started_at);
+      const finish = Date.parse(segment.finished_at);
+      const contained = taskMatches.filter((run) => {
+        const occurred = Date.parse(run.started.occurred_at);
+        return Number.isFinite(occurred) && occurred >= start && occurred <= finish;
+      });
+      if (contained.length === 1)
+        candidates.push({ run: contained[0], segment, confidence: "task_id_time_containment" });
+    }
+    const conversationMatches = legacyMissing.filter(
+      (run) => run.started.conversation_id && segment.raw.includes(run.started.conversation_id),
+    );
+    if (taskMatches.length === 0 && conversationMatches.length === 1)
+      candidates.push({
+        run: conversationMatches[0],
+        segment,
+        confidence: "exact_conversation_id",
+      });
+  }
+  const alreadyCandidate = candidates.some((candidate) => candidate.segment.key === segment.key);
+  if (!alreadyCandidate && segment.started_at && segment.finished_at) {
+    const start = Date.parse(segment.started_at);
+    const finish = Date.parse(segment.finished_at);
+    const contained = legacyMissing.filter((run) => {
+      const occurred = Date.parse(run.started.occurred_at);
+      return Number.isFinite(occurred) && occurred >= start && occurred <= finish;
+    });
+    if (contained.length === 1)
+      candidates.push({ run: contained[0], segment, confidence: "exclusive_time_containment" });
+  }
+}
+const candidateRunIds = new Set(candidates.map((candidate) => candidate.run.started.run_id));
+const candidateSegmentKeys = new Set(candidates.map((candidate) => candidate.segment.key));
+const remainingRuns = missing.filter(
+  (run) => !run.started.client_turn_id && !candidateRunIds.has(run.started.run_id),
+);
+const remainingSegments = segments.filter(
+  (segment) => !candidateSegmentKeys.has(segment.key) && segment.started_at,
+);
+const distance = (run, segment) =>
+  Math.abs(Date.parse(run.started.occurred_at) - Date.parse(segment.started_at));
+for (const run of remainingRuns) {
+  const orderedSegments = remainingSegments
+    .map((segment) => ({ segment, distance: distance(run, segment) }))
+    .sort((a, b) => a.distance - b.distance);
+  const nearest = orderedSegments[0];
+  if (!nearest || nearest.distance > 120_000 || nearest.distance === orderedSegments[1]?.distance)
+    continue;
+  const orderedRuns = remainingRuns
+    .map((other) => ({ run: other, distance: distance(other, nearest.segment) }))
+    .sort((a, b) => a.distance - b.distance);
+  if (
+    orderedRuns[0]?.run.started.run_id === run.started.run_id &&
+    orderedRuns[0].distance !== orderedRuns[1]?.distance
+  ) {
+    candidates.push({ run, segment: nearest.segment, confidence: "mutual_nearest_start_120s" });
+  }
+}
+if (approximate) {
+  const hints = new Map(
+    candidates.map((candidate) => [
+      `${candidate.run.started.run_id}|${candidate.segment.key}`,
+      candidate.confidence,
+    ]),
+  );
+  const canonical = candidates.filter((candidate) =>
+    candidate.confidence.startsWith("exact_client_turn"),
+  );
+  const assignedRuns = new Set(canonical.map((candidate) => candidate.run.started.run_id));
+  const assignedSegments = new Set(canonical.map((candidate) => candidate.segment.key));
+  const approximateRuns = missing.filter(
+    (run) => !run.started.client_turn_id && !assignedRuns.has(run.started.run_id),
+  );
+  const approximateSegments = segments.filter(
+    (segment) => !assignedSegments.has(segment.key) && segment.started_at,
+  );
+  const pairs = [];
+  for (const run of approximateRuns) {
+    const runFinished = run.records.find((record) => recordType(record) === "run.finished");
+    const runDuration = runFinished
+      ? Math.max(0, Date.parse(recordOccurredAt(runFinished)) - Date.parse(run.started.occurred_at))
+      : null;
+    for (const segment of approximateSegments) {
+      const startDelta = Math.abs(
+        Date.parse(run.started.occurred_at) - Date.parse(segment.started_at),
+      );
+      const segmentDuration = segment.finished_at
+        ? Math.max(0, Date.parse(segment.finished_at) - Date.parse(segment.started_at))
+        : null;
+      const durationDelta =
+        runDuration !== null && segmentDuration !== null
+          ? Math.abs(runDuration - segmentDuration)
+          : 0;
+      const hint = hints.get(`${run.started.run_id}|${segment.key}`) ?? null;
+      const hintBonus =
+        hint === "exact_run_id"
+          ? 1e15
+          : hint === "exact_task_id"
+            ? 1e14
+            : hint === "exact_conversation_id"
+              ? 1e13
+              : hint?.includes("containment")
+                ? 1e12
+                : hint === "mutual_nearest_start_120s"
+                  ? 1e11
+                  : 0;
+      pairs.push({
+        run,
+        segment,
+        score: startDelta + durationDelta * 0.35 - hintBonus,
+        startDelta,
+        durationDelta,
+        hint,
+      });
+    }
+  }
+  pairs.sort(
+    (left, right) =>
+      left.score - right.score ||
+      left.startDelta - right.startDelta ||
+      left.durationDelta - right.durationDelta,
+  );
+  const usedRuns = new Set();
+  const usedSegments = new Set();
+  candidates = [...canonical];
+  for (const pair of pairs) {
+    const runId = pair.run.started.run_id;
+    if (usedRuns.has(runId) || usedSegments.has(pair.segment.key)) continue;
+    usedRuns.add(runId);
+    usedSegments.add(pair.segment.key);
+    candidates.push({
+      ...pair,
+      confidence: `approximate_global_${pair.hint ?? "time_duration"}`,
+    });
+  }
+}
+const byRun = new Map();
+const bySegment = new Map();
+for (const candidate of candidates) {
+  byRun.set(candidate.run.started.run_id, [
+    ...(byRun.get(candidate.run.started.run_id) ?? []),
+    candidate,
+  ]);
+  bySegment.set(candidate.segment.key, [
+    ...(bySegment.get(candidate.segment.key) ?? []),
+    candidate,
+  ]);
+}
+const eligible = candidates.filter(
+  (candidate) =>
+    byRun.get(candidate.run.started.run_id).length === 1 &&
+    bySegment.get(candidate.segment.key).length === 1,
+);
+
+if (applyBackfill) {
+  for (const { run, segment, confidence } of eligible) {
+    const tokens = aggregate(segment);
+    const model = segment.model ?? run.started.model ?? null;
+    const cost = await pricingFor(workspace, model, tokens);
+    const superseded = [...run.usage]
+      .reverse()
+      .find(
+        (event) =>
+          event.tokens?.total === null &&
+          !run.usage.some((other) => other.supersedes_event_id === event.event_id),
+      );
+    const sequence = Math.max(...run.records.map((record) => recordSequence(record) ?? 0)) + 1;
+    const event = {
+      schema_version: 2,
+      event_id: `${run.started.run_id}:reconcile:${String(sequence).padStart(6, "0")}`,
+      run_id: run.started.run_id,
+      sequence,
+      occurred_at: run.records.find((record) => recordType(record) === "run.finished")
+        ? new Date(
+            Date.parse(
+              recordOccurredAt(run.records.find((record) => recordType(record) === "run.finished")),
+            ) - 1,
+          ).toISOString()
+        : new Date().toISOString(),
+      type: "usage.recorded",
+      phase: run.started.phase,
+      activity_kind: "retrospective_local_reconciliation",
+      classification_source: confidence.startsWith("approximate_")
+        ? "legacy_inferred"
+        : "current_context",
+      tokens: { ...tokens, source: "provider_reported" },
+      cost,
+      provider: run.started.provider ?? "openai",
+      model,
+      source_segment_key: segment.key,
+      supersedes_event_id: superseded?.event_id ?? null,
+      source_occurred_at: segment.finished_at ?? segment.started_at,
+      runtime: { reasoning_effort: segment.effort, service_tier: segment.service_tier },
+    };
+    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), event, ...run.records.slice(insertAt)].map(
+      (record, index) => withSequence(record, index + 1),
+    );
+    const temporary = `${run.file}.reconcile.tmp`;
+    await writeFile(
+      temporary,
+      `${updated.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, run.file);
+  }
+}
+
+const ambiguousRunIds = [
+  ...new Set([
+    ...[...byRun.entries()].filter(([, values]) => values.length > 1).map(([id]) => id),
+    ...[...bySegment.values()]
+      .filter((values) => values.length > 1)
+      .flatMap((values) => values.map(({ run }) => run.started.run_id)),
+  ]),
+];
+const matchedIds = new Set(eligible.map(({ run }) => run.started.run_id));
+const corrections = runs.flatMap((run) =>
+  run.usage.filter((usage) => usage.activity_kind === "retrospective_local_reconciliation"),
+);
+const correctionKeys = corrections.map((usage) => usage.source_segment_key).filter(Boolean);
+console.log(
+  JSON.stringify(
+    {
+      mode: deduplicate
+        ? apply
+          ? "apply-deduplicate"
+          : "dry-run-deduplicate"
+        : apply
+          ? reprice
+            ? "apply-reprice"
+            : approximate
+              ? "apply-approximate"
+              : "apply"
+          : reprice
+            ? "dry-run-reprice"
+            : approximate
+              ? "dry-run-approximate"
+              : "dry-run",
+      run_files: runs.length,
+      local_session_files: new Set(segments.map((segment) => segment.file)).size,
+      local_segments_available: segments.length,
+      already_measured: runs.filter((run) => run.measured).length,
+      missing_before: missing.length,
+      unfinished_before: unfinished.length,
+      unfinished_finish_eligible: finishEligible.length,
+      unfinished_finish_applied: applyBackfill ? finishEligible.length : 0,
+      unfinished_finish_ambiguous: finishAmbiguous.length,
+      eligible: eligible.length,
+      applied: applyBackfill ? eligible.length : 0,
+      ambiguous: ambiguousRunIds.length,
+      unmatched: missing.filter(
+        (run) =>
+          !matchedIds.has(run.started.run_id) && !ambiguousRunIds.includes(run.started.run_id),
+      ).length,
+      corrections_recorded: corrections.length,
+      invalid_correction_totals: corrections.filter(
+        (usage) => usage.tokens.total !== usage.tokens.input + usage.tokens.output,
+      ).length,
+      duplicated_correction_segments: correctionKeys.length - new Set(correctionKeys).size,
+      duplicate_segment_groups: duplicateGroups.length,
+      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,
+      repriced_runs: repricedRuns,
+      repriced_events: repricedEvents,
+      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),
+      confidence: Object.fromEntries(
+        eligible.map(({ run, confidence }) => [run.started.run_id, confidence]),
+      ),
+    },
+    null,
+    2,
+  ),
+);