@zaip-ai/cli 1.0.7 → 1.3.0

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

@@ -3,8 +3,10 @@ import { join, resolve } from "node:path";
 import {
   aggregate,
   duplicateUsageAssignments,
+  duplicateUsageImpact,
   exactCompletedSegment,
   filesUnder,
+  isExactDuplicateUsageGroup,
   jsonLines,
   loadSegments,
   pricingFor,
@@ -12,11 +14,16 @@ import {
   recordSequence,
   recordType,
   sameCost,
+  supersedableUsageBeforeTerminal,
   usageStatus,
   usageView,
   withSequence,
 } from "./reconcile-telemetry-lib.mjs";
-import { remeasureSelectedRuns } from "./reconcile-telemetry-remeasurement.mjs";
+import {
+  remeasureSelectedRuns,
+  timingEnrichmentRunIds,
+} from "./reconcile-telemetry-remeasurement.mjs";
+import { reconcileGenericModelIdentities } from "./source-size-telemetry/model-identity-reconciliation.mjs";
 
 const workspace = resolve(process.cwd());
 const apply = process.argv.includes("--apply");
@@ -39,9 +46,21 @@ const selectedRunIds = new Set(
         : [],
   ),
 );
+const selectedSessionFiles = process.argv
+  .flatMap((argument, index, values) =>
+    argument === "--session-file"
+      ? [String(values[index + 1] ?? "")]
+      : argument.startsWith("--session-file=")
+        ? [argument.slice("--session-file=".length)]
+        : [],
+  )
+  .filter(Boolean);
 if (remeasure && selectedRunIds.size === 0) {
   throw new Error("--remeasure requires at least one explicit --run <RUN-ID>");
 }
+if (apply && deduplicate && selectedRunIds.size === 0) {
+  throw new Error("--apply --deduplicate requires at least one explicit --run <RUN-ID>");
+}
 const applyBackfill = apply && !deduplicate && !remeasure;
 
 const runFiles = await filesUnder(join(workspace, ".agents", "records", "runs"), ".jsonl");
@@ -166,20 +185,35 @@ for (const file of runFiles) {
     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 });
+  if (started) runs.push({ file, records, started, usage, measured, deduplicated, nativeMeasured });
 }
 
-const allSegments = await loadSegments(workspace);
-const remeasurement = remeasure
-  ? await remeasureSelectedRuns({
-      apply,
-      allSegments,
-      runs,
-      selectedRunIds,
-      timingOnly,
-      workspace,
-    })
-  : [];
+const allSegments = await loadSegments(
+  workspace,
+  selectedSessionFiles.length === 0 ? null : selectedSessionFiles,
+);
+// Native usage can be captured before the Codex session emits task_complete.
+// A normal backfill must not replace those observed tokens or costs, but it can
+// append an exact, timing-only correction once that terminal boundary appears.
+const timingRunIds = timingEnrichmentRunIds({
+  remeasure,
+  applyBackfill,
+  selectedRunIds,
+  runs,
+});
+const remeasurement =
+  remeasure || (applyBackfill && timingRunIds.size > 0)
+    ? await remeasureSelectedRuns({
+        apply,
+        allSegments,
+        runs,
+        selectedRunIds: timingRunIds,
+        // Automatic backfill is intentionally timing-only. Explicit remeasurement
+        // retains its existing token/cost correction behavior unless requested.
+        timingOnly: remeasure ? timingOnly : true,
+        workspace,
+      })
+    : [];
 const unfinished = runs.filter(
   (run) => !run.records.some((record) => recordType(record) === "run.finished"),
 );
@@ -285,73 +319,36 @@ if (reprice) {
   }
 }
 
-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 modelIdentityCorrections = await reconcileGenericModelIdentities({
+  applyBackfill,
+  pricingFor,
+  runs,
+  segments: allSegments,
+  usageView,
+  withSequence,
+  workspace,
+});
 
 const duplicateGroups = duplicateUsageAssignments(runs);
-const duplicateAssignments = duplicateGroups.flatMap((group) => group.slice(1));
+const exactDuplicateGroups = duplicateGroups.filter(isExactDuplicateUsageGroup);
+const aliasReviewGroups = duplicateGroups.filter((group) => !isExactDuplicateUsageGroup(group));
+const selectedDuplicateGroups =
+  selectedRunIds.size === 0
+    ? exactDuplicateGroups
+    : exactDuplicateGroups.filter((group) =>
+        group.some(({ run }) => selectedRunIds.has(run.started.run_id)),
+      );
+const selectedAliasReviewGroups =
+  selectedRunIds.size === 0
+    ? aliasReviewGroups
+    : 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)),
+);
 let deduplicatedEvents = 0;
 if (apply && deduplicate) {
   for (const { run, usage } of duplicateAssignments) {
@@ -594,32 +591,36 @@ for (const candidate of candidates) {
 }
 const eligible = candidates.filter(
   (candidate) =>
+    (selectedRunIds.size === 0 || selectedRunIds.has(candidate.run.started.run_id)) &&
     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) {
+    // Re-read each Run under the serial apply loop: a preceding timing repair may
+    // have reordered or appended a correction after the initial scan.
+    const persistedRecords = jsonLines(await readFile(run.file, "utf8"));
+    const finishIndex = persistedRecords.findIndex(
+      (record) => recordType(record) === "run.finished",
+    );
+    const insertAt = finishIndex < 0 ? persistedRecords.length : finishIndex;
     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 superseded = supersedableUsageBeforeTerminal(persistedRecords);
+    const sequence = Math.max(...persistedRecords.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")
+      occurred_at: persistedRecords.find((record) => recordType(record) === "run.finished")
         ? new Date(
             Date.parse(
-              recordOccurredAt(run.records.find((record) => recordType(record) === "run.finished")),
+              recordOccurredAt(
+                persistedRecords.find((record) => recordType(record) === "run.finished"),
+              ),
             ) - 1,
           ).toISOString()
         : new Date().toISOString(),
@@ -640,11 +641,11 @@ if (applyBackfill) {
       ...(segment.finished_at ? { source_finished_at: segment.finished_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 updated = [
+      ...persistedRecords.slice(0, insertAt),
+      event,
+      ...persistedRecords.slice(insertAt),
+    ].map((record, index) => withSequence(record, index + 1));
     const temporary = `${run.file}.reconcile.tmp`;
     await writeFile(
       temporary,
@@ -722,6 +723,11 @@ console.log(
       ).length,
       duplicated_correction_segments: correctionKeys.length - new Set(correctionKeys).size,
       duplicate_segment_groups: duplicateGroups.length,
+      exact_source_key_groups: exactDuplicateGroups.length,
+      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),
       duplicate_segment_assignments: duplicateAssignments.length,
       duplicate_segment_run_ids: duplicateGroups.map((group) =>
         group.map(({ run }) => run.started.run_id),

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

@@ -112,6 +112,21 @@ export function usageView(record) {
   };
 }
 
+export function supersedableUsageBeforeTerminal(records) {
+  const finishIndex = records.findIndex((record) => recordType(record) === "run.finished");
+  const beforeTerminal = records.slice(0, finishIndex < 0 ? records.length : finishIndex);
+  const usage = beforeTerminal.map(usageView).filter(Boolean);
+  return (
+    [...usage]
+      .reverse()
+      .find(
+        (event) =>
+          event.tokens?.total === null &&
+          !usage.some((other) => other.supersedes_event_id === event.event_id),
+      ) ?? null
+  );
+}
+
 export function withSequence(record, sequence) {
   if (!Array.isArray(record)) return { ...record, sequence };
   const copy = [...record];
@@ -127,6 +142,10 @@ export function canonicalSegmentKey(sourceSegmentKey) {
   return (sessionsMarker < 0 ? normalized : normalized.slice(sessionsMarker + 1)).toLowerCase();
 }
 
+function normalizedRawSegmentKey(sourceSegmentKey) {
+  return String(sourceSegmentKey).replaceAll("\\", "/").toLowerCase();
+}
+
 export function usageStatus(usage) {
   const superseded = new Set(usage.map((event) => event.supersedes_event_id).filter(Boolean));
   const effective = usage.filter((event) => !superseded.has(event.event_id));
@@ -153,18 +172,14 @@ export function duplicateUsageAssignments(runs) {
         continue;
       }
       const baseSegmentKey = canonicalSegmentKey(usage.source_segment_key);
-      const signature = JSON.stringify([
-        baseSegmentKey,
-        run.started.client_turn_id ?? null,
-        usage.tokens.input,
-        usage.tokens.cached_input,
-        usage.tokens.output,
-        usage.tokens.reasoning,
-        usage.tokens.total,
-      ]);
-      groups.set(signature, [
-        ...(groups.get(signature) ?? []),
-        { run, usage, base_segment_key: baseSegmentKey },
+      groups.set(baseSegmentKey, [
+        ...(groups.get(baseSegmentKey) ?? []),
+        {
+          run,
+          usage,
+          base_segment_key: baseSegmentKey,
+          raw_segment_key: normalizedRawSegmentKey(usage.source_segment_key),
+        },
       ]);
     }
   }
@@ -173,13 +188,57 @@ export function duplicateUsageAssignments(runs) {
     .map((group) =>
       [...group].sort(
         (left, right) =>
+          provenanceRank(left.usage) - provenanceRank(right.usage) ||
           String(left.run.started.occurred_at).localeCompare(
             String(right.run.started.occurred_at),
-          ) || left.run.started.run_id.localeCompare(right.run.started.run_id),
+          ) ||
+          left.run.started.run_id.localeCompare(right.run.started.run_id),
       ),
     );
 }
 
+export function isExactDuplicateUsageGroup(group) {
+  return new Set(group.map(({ raw_segment_key }) => raw_segment_key)).size === 1;
+}
+
+export function duplicateUsageImpact(assignments) {
+  const impact = {
+    assignments: assignments.length,
+    input_tokens: 0,
+    output_tokens: 0,
+    total_tokens: 0,
+    cost_usd: 0,
+    cost_brl: 0,
+    duration_ms: 0,
+    duration_assignments: 0,
+  };
+  for (const { usage } of assignments) {
+    for (const [key, value] of [
+      ["input_tokens", usage.tokens?.input],
+      ["output_tokens", usage.tokens?.output],
+      ["total_tokens", usage.tokens?.total],
+      ["cost_usd", usage.cost?.usd],
+      ["cost_brl", usage.cost?.brl],
+    ]) {
+      if (Number.isFinite(value)) impact[key] += value;
+    }
+    const start = Date.parse(usage.source_started_at ?? "");
+    const finish = Date.parse(usage.source_finished_at ?? "");
+    if (Number.isFinite(start) && Number.isFinite(finish) && finish >= start) {
+      impact.duration_ms += finish - start;
+      impact.duration_assignments += 1;
+    }
+  }
+  return impact;
+}
+
+function provenanceRank(usage) {
+  const source = usage.classification_source ?? "";
+  if (source === "current_context" || source.startsWith("exact_")) return 0;
+  if (usage.activity_kind !== "retrospective_local_reconciliation") return 1;
+  return source === "legacy_inferred" ? 2 : 1;
+}
+
 export function exactCompletedSegment(started, segments) {
   if (!started?.client_turn_id) return { segment: null, ambiguous: false };
   const runStartedAt = Date.parse(started.occurred_at ?? "");
@@ -198,7 +257,13 @@ export function exactCompletedSegment(started, segments) {
   };
 }
 
-export function exactRemeasurementSegment(started, sourceSegmentKey, segments) {
+export function exactRemeasurementSegment(
+  started,
+  sourceSegmentKey,
+  segments,
+  sourceOccurredAt = null,
+  sourceTokens = null,
+) {
   const turnMatch = exactCompletedSegment(started, segments);
   if (turnMatch.segment !== null || turnMatch.ambiguous) return turnMatch;
   if (typeof sourceSegmentKey !== "string") return turnMatch;
@@ -207,9 +272,50 @@ export function exactRemeasurementSegment(started, sourceSegmentKey, segments) {
       segment.finished_at !== null &&
       canonicalSegmentKey(segment.key) === canonicalSegmentKey(sourceSegmentKey),
   );
+  if (matches.length === 1) return { segment: matches[0], ambiguous: false };
+
+  const sourceFinishedAt = Date.parse(sourceOccurredAt ?? "");
+  const sourceFile = canonicalSegmentKey(sourceSegmentKey).replace(/#\d+$/, "");
+  const timeMatches = Number.isFinite(sourceFinishedAt)
+    ? segments.filter(
+        (segment) =>
+          segment.finished_at !== null &&
+          Date.parse(segment.finished_at) === sourceFinishedAt &&
+          canonicalSegmentKey(segment.key).replace(/#\d+$/, "") === sourceFile,
+      )
+    : [];
+  if (timeMatches.length === 1) return { segment: timeMatches[0], ambiguous: false };
+
+  const tokenMatches =
+    sourceTokens !== null
+      ? segments.filter((segment) => {
+          if (canonicalSegmentKey(segment.key).replace(/#\d+$/, "") !== sourceFile) return false;
+          if (segment.finished_at === null || !Array.isArray(segment.usage)) return false;
+          const tokens = aggregate(segment);
+          const last = segment.usage.at(-1);
+          const lastTokens = last
+            ? {
+                input: last.input_tokens,
+                cached_input: last.cached_input_tokens,
+                output: last.output_tokens,
+                reasoning: last.reasoning_output_tokens,
+                total: last.total_tokens,
+              }
+            : null;
+          const same = (candidate) =>
+            candidate !== null &&
+            ["input", "cached_input", "output", "reasoning", "total"].every(
+              (key) => candidate[key] === sourceTokens[key],
+            );
+          return same(tokens) || same(lastTokens);
+        })
+      : [];
   return {
-    segment: matches.length === 1 ? matches[0] : null,
-    ambiguous: matches.length > 1,
+    segment: tokenMatches.length === 1 ? tokenMatches[0] : null,
+    ambiguous:
+      timeMatches.length > 1 ||
+      tokenMatches.length > 1 ||
+      (timeMatches.length === 0 && tokenMatches.length === 0 && matches.length > 1),
   };
 }
 
@@ -217,11 +323,10 @@ function normalized(path) {
   return resolve(path).replaceAll("\\", "/").toLowerCase();
 }
 
-export async function loadSegments(workspace) {
-  const sessionFiles = await filesUnder(join(homedir(), ".codex", "sessions"), ".jsonl");
+export async function loadSegments(workspace, sessionFiles = null) {
+  const files = sessionFiles ?? (await filesUnder(join(homedir(), ".codex", "sessions"), ".jsonl"));
   const segments = [];
-  for (const file of sessionFiles) {
-    const fileSegmentStart = segments.length;
+  for (const file of files) {
     let canonicalSessionMetaSeen = false;
     let workspaceMatches = false;
     let sessionId = null;
@@ -245,17 +350,21 @@ export async function loadSegments(workspace) {
       }
       const payload = record?.payload && typeof record.payload === "object" ? record.payload : null;
       if (record.type === "session_meta" && typeof payload?.cwd === "string") {
+        const nextSessionId = canonicalSessionId(payload);
+        const sameSession = canonicalSessionMetaSeen && nextSessionId === sessionId;
+        if (sameSession) {
+          workspaceMatches = normalized(payload.cwd) === normalized(workspace);
+          continue;
+        }
         if (canonicalSessionMetaSeen) {
-          segments.splice(fileSegmentStart);
           current = null;
           index = 0;
           latestCumulativeUsage = null;
           latestIncrementalUsage = null;
-          continue;
         }
         canonicalSessionMetaSeen = true;
         workspaceMatches = normalized(payload.cwd) === normalized(workspace);
-        sessionId = canonicalSessionId(payload);
+        sessionId = nextSessionId;
       }
       if (!workspaceMatches) continue;
       const settings = payload?.type === "thread_settings_applied" ? payload.thread_settings : null;

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

@@ -8,13 +8,16 @@ import {
   canonicalSessionId,
   cumulativeSnapshotDelta,
   duplicateUsageAssignments,
+  duplicateUsageImpact,
   exactCompletedSegment,
   exactRemeasurementSegment,
+  isExactDuplicateUsageGroup,
   jsonLines,
   pricingFor,
   recordSequence,
   recordType,
   sameTokenSnapshot,
+  supersedableUsageBeforeTerminal,
   usageStatus,
   usageView,
   withSequence,
@@ -23,6 +26,41 @@ import {
 const roots = [];
 after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
 
+test("sums duplicate assignment impact without inventing duration", () => {
+  assert.deepEqual(
+    duplicateUsageImpact([
+      {
+        usage: {
+          tokens: { input: 2, output: 3, total: 5 },
+          cost: { usd: 1, brl: 5 },
+          source_started_at: "2026-01-01T00:00:00Z",
+          source_finished_at: "2026-01-01T00:00:01Z",
+        },
+      },
+    ]),
+    {
+      assignments: 1,
+      input_tokens: 2,
+      output_tokens: 3,
+      total_tokens: 5,
+      cost_usd: 1,
+      cost_brl: 5,
+      duration_ms: 1000,
+      duration_assignments: 1,
+    },
+  );
+});
+
+test("never supersedes usage recorded after run.finished", () => {
+  const records = [
+    { type: "run.started", sequence: 1 },
+    { type: "usage.recorded", sequence: 2, event_id: "before", tokens: { total: null } },
+    { type: "run.finished", sequence: 3 },
+    { type: "usage.recorded", sequence: 4, event_id: "after", tokens: { total: null } },
+  ];
+  assert.equal(supersedableUsageBeforeTerminal(records)?.event_id, "before");
+});
+
 test("normalizes compact and object Run records without changing usage totals", () => {
   const compact = [
     2,
@@ -193,6 +231,70 @@ test("remeasurement falls back only to the exact persisted source segment key",
     ),
     { segment: null, ambiguous: true },
   );
+
+  const resumedTarget = {
+    ...target,
+    key: "c:/users/test/.codex/sessions/2026/07/25/child.jsonl#18",
+    finished_at: "2026-07-25T04:15:30.000Z",
+  };
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: null, occurred_at: "2026-07-25T04:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#2",
+      [target, resumedTarget],
+      "2026-07-25T04:15:30.000Z",
+    ),
+    { segment: resumedTarget, ambiguous: false },
+  );
+
+  const tokenTarget = {
+    ...resumedTarget,
+    finished_at: "2026-07-25T04:16:00.000Z",
+    usage: [
+      {
+        input_tokens: 90,
+        cached_input_tokens: 80,
+        output_tokens: 10,
+        reasoning_output_tokens: 2,
+        total_tokens: 100,
+      },
+    ],
+  };
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: null, occurred_at: "2026-07-25T04:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#2",
+      [target, tokenTarget],
+      "2026-07-25T04:15:59.000Z",
+      { input: 90, cached_input: 80, output: 10, reasoning: 2, total: 100 },
+    ),
+    { segment: tokenTarget, ambiguous: false },
+  );
+
+  const cumulativeSnapshotTarget = {
+    ...tokenTarget,
+    key: "c:/users/test/.codex/sessions/2026/07/25/child.jsonl#19",
+    usage: [
+      tokenTarget.usage[0],
+      {
+        input_tokens: 40,
+        cached_input_tokens: 30,
+        output_tokens: 4,
+        reasoning_output_tokens: 1,
+        total_tokens: 44,
+      },
+    ],
+  };
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: null, occurred_at: "2026-07-25T04:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#2",
+      [target, cumulativeSnapshotTarget],
+      null,
+      { input: 40, cached_input: 30, output: 4, reasoning: 1, total: 44 },
+    ),
+    { segment: cumulativeSnapshotTarget, ambiguous: false },
+  );
 });
 
 test("detects only exact duplicate segment assignments across Runs", () => {
@@ -239,7 +341,7 @@ test("detects only exact duplicate segment assignments across Runs", () => {
   assert.equal(groups.length, 1);
   assert.deepEqual(
     groups[0].map(({ run: item }) => item.started.run_id),
-    ["RUN-FIRST", "RUN-DUPLICATE"],
+    ["RUN-FIRST", "RUN-DUPLICATE", "RUN-DELTA"],
   );
   assert.equal(groups[0][0].base_segment_key, "sessions/2026/07/17/session.jsonl#1");
 });
@@ -264,3 +366,49 @@ test("keeps duplicate reconciliation unavailable and protected from backfill", (
   assert.equal(status.deduplicated, true);
   assert.deepEqual(status.effective, [correction]);
 });
+
+test("prefers later current-context assignment over earlier legacy assignment", () => {
+  const run = (id, occurred_at, client_turn_id, classification_source, total) => ({
+    started: { run_id: id, occurred_at, client_turn_id },
+    usage: [
+      {
+        event_id: `${id}:usage`,
+        source_segment_key: "sessions/x.jsonl#1",
+        supersedes_event_id: null,
+        classification_source,
+        tokens: { input: total - 1, output: 1, total },
+      },
+    ],
+  });
+  const [group] = duplicateUsageAssignments([
+    run("XCHW", "2026-07-01T00:00:00.000Z", "legacy-turn", "legacy_inferred", 9_278_701),
+    run("HF77", "2026-07-01T00:01:00.000Z", "exact-turn", "current_context", 577),
+  ]);
+  assert.equal(group[0].run.started.run_id, "HF77");
+  assert.equal(group[1].run.started.run_id, "XCHW");
+});
+
+test("keeps canonical aliases in review instead of making them apply candidates", () => {
+  const run = (id, source_segment_key) => ({
+    started: { run_id: id, occurred_at: "2026-07-01T00:00:00.000Z" },
+    usage: [
+      {
+        event_id: `${id}:usage`,
+        source_segment_key,
+        supersedes_event_id: null,
+        tokens: { input: 1, output: 1, total: 2 },
+      },
+    ],
+  });
+  const [aliasGroup] = duplicateUsageAssignments([
+    run("RUN-A", "sessions/x.jsonl#1@RUN-A"),
+    run("RUN-B", "sessions/x.jsonl#1@RUN-B"),
+  ]);
+  const [exactGroup] = duplicateUsageAssignments([
+    run("RUN-C", "sessions/x.jsonl#2"),
+    run("RUN-D", "SESSIONS\\x.jsonl#2"),
+  ]);
+
+  assert.equal(isExactDuplicateUsageGroup(aliasGroup), false);
+  assert.equal(isExactDuplicateUsageGroup(exactGroup), true);
+});