@zaip-ai/cli 1.0.4 → 1.0.7

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

@@ -1,698 +0,0 @@
-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,
-  ),
-);