@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -1,28 +1,35 @@
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import {
+  applyExplicitTurnRecovery,
+  normalizeExplicitTurnRecoverySchema,
+  parseExplicitTurnMappings,
+  planExplicitTurnRecovery,
+} from "./reconcile-telemetry-explicit-recovery.mjs";
 import {
   aggregate,
   duplicateUsageAssignments,
   duplicateUsageImpact,
   exactCompletedSegment,
   filesUnder,
-  jsonLines,
   isExactDuplicateUsageGroup,
+  jsonLines,
   loadSegments,
   pricingFor,
   recordOccurredAt,
   recordSequence,
   recordType,
   sameCost,
+  supersedableUsageBeforeTerminal,
   usageStatus,
   usageView,
-  supersedableUsageBeforeTerminal,
   withSequence,
 } from "./reconcile-telemetry-lib.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");
@@ -31,6 +38,7 @@ const reprice = process.argv.includes("--reprice");
 const deduplicate = process.argv.includes("--deduplicate");
 const remeasure = process.argv.includes("--remeasure");
 const timingOnly = process.argv.includes("--timing-only");
+const explicitRecovery = process.argv.includes("--explicit-turn-recovery");
 if (timingOnly && !remeasure) {
   throw new Error("--timing-only requires --remeasure");
 }
@@ -54,13 +62,19 @@ const selectedSessionFiles = process.argv
         : [],
   )
   .filter(Boolean);
+const explicitMappings = parseExplicitTurnMappings(
+  process.argv,
+  explicitRecovery,
+  selectedRunIds,
+  selectedSessionFiles,
+);
 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 applyBackfill = apply && !deduplicate && !remeasure && !explicitRecovery;
 
 const runFiles = await filesUnder(join(workspace, ".agents", "records", "runs"), ".jsonl");
 const runs = [];
@@ -191,9 +205,38 @@ 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.
+let explicitSchemaNormalized = false;
+if (apply && explicitRecovery) {
+  const run = runs.find((candidate) => candidate.started.run_id === [...selectedRunIds][0]);
+  if (run) {
+    const normalized = await normalizeExplicitTurnRecoverySchema(
+      run.file,
+      run.records,
+      explicitMappings,
+    );
+    if (normalized !== run.records) {
+      run.records = normalized;
+      run.usage = normalized
+        .filter((record) => recordType(record) === "usage.recorded")
+        .map(usageView);
+      explicitSchemaNormalized = true;
+    }
+  }
+}
+const explicitRecoveryPlan = explicitRecovery
+  ? (() => {
+      const runId = [...selectedRunIds][0];
+      const run = runs.find((candidate) => candidate.started.run_id === runId);
+      return run
+        ? planExplicitTurnRecovery({ run, segments: allSegments, mappings: explicitMappings })
+        : { run_id: runId, eligible: false, reasons: ["run-not-found"], turns: [], recovered: [] };
+    })()
+  : null;
+if (apply && explicitRecovery && explicitRecoveryPlan.eligible) {
+  const run = runs.find((candidate) => candidate.started.run_id === explicitRecoveryPlan.run_id);
+  await applyExplicitTurnRecovery({ run, plan: explicitRecoveryPlan });
+  explicitRecoveryPlan.applied = true;
+}
 const timingRunIds = timingEnrichmentRunIds({
   remeasure,
   applyBackfill,
@@ -207,8 +250,6 @@ const remeasurement =
         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,
       })
@@ -318,86 +359,35 @@ 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 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 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)),
+  group
+    .slice(1)
+    .filter(({ run }) => selectedRunIds.size === 0 || selectedRunIds.has(run.started.run_id)),
 );
 let deduplicatedEvents = 0;
 if (apply && deduplicate) {
@@ -641,16 +631,17 @@ 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 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;
@@ -665,7 +656,9 @@ if (applyBackfill) {
       occurred_at: persistedRecords.find((record) => recordType(record) === "run.finished")
         ? new Date(
             Date.parse(
-              recordOccurredAt(persistedRecords.find((record) => recordType(record) === "run.finished")),
+              recordOccurredAt(
+                persistedRecords.find((record) => recordType(record) === "run.finished"),
+              ),
             ) - 1,
           ).toISOString()
         : new Date().toISOString(),
@@ -686,9 +679,11 @@ if (applyBackfill) {
       ...(segment.finished_at ? { source_finished_at: segment.finished_at } : {}),
       runtime: { reasoning_effort: segment.effort, service_tier: segment.service_tier },
     };
-    const updated = [...persistedRecords.slice(0, insertAt), event, ...persistedRecords.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,
@@ -719,23 +714,35 @@ console.log(
         ? apply
           ? "apply-deduplicate"
           : "dry-run-deduplicate"
-        : remeasure
+        : explicitRecovery
           ? apply
-            ? "apply-remeasure"
-            : "dry-run-remeasure"
-          : apply
-            ? reprice
-              ? "apply-reprice"
-              : approximate
-                ? "apply-approximate"
-                : "apply"
-            : reprice
-              ? "dry-run-reprice"
-              : approximate
-                ? "dry-run-approximate"
-                : "dry-run",
+            ? "apply-explicit-turn-recovery"
+            : "dry-run-explicit-turn-recovery"
+          : remeasure
+            ? apply
+              ? "apply-remeasure"
+              : "dry-run-remeasure"
+            : apply
+              ? reprice
+                ? "apply-reprice"
+                : approximate
+                  ? "apply-approximate"
+                  : "apply"
+              : reprice
+                ? "dry-run-reprice"
+                : approximate
+                  ? "dry-run-approximate"
+                  : "dry-run",
       run_files: runs.length,
       remeasurement,
+      explicit_turn_recovery: explicitRecoveryPlan && {
+        run_id: explicitRecoveryPlan.run_id,
+        eligible: explicitRecoveryPlan.eligible,
+        applied: explicitRecoveryPlan.applied === true,
+        reasons: explicitRecoveryPlan.reasons,
+        turns: explicitRecoveryPlan.turns,
+        schema_normalized: explicitSchemaNormalized,
+      },
       local_session_files: new Set(segments.map((segment) => segment.file)).size,
       local_segments_available: segments.length,
       already_measured: runs.filter((run) => run.measured).length,

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

@@ -0,0 +1,223 @@
+import { open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import {
+  aggregate,
+  jsonLines,
+  recordPhase,
+  recordType,
+  usageStatus,
+  usageView,
+  withSequence,
+} from "./reconcile-telemetry-lib.mjs";
+
+export function parseExplicitTurnMappings(args, enabled, runIds, sessionFiles) {
+  const mappings = args.flatMap((argument, index, values) => {
+    if (argument !== "--explicit-turn") return [];
+    const [spec_id, turn_id, total, usd, brl] = String(values[index + 1] ?? "").split("|");
+    return [{ spec_id, turn_id, total: Number(total), usd: Number(usd), brl: Number(brl) }];
+  });
+  if (enabled && (runIds.size !== 1 || sessionFiles.length !== 1))
+    throw new Error("--explicit-turn-recovery requires exactly one --run and one --session-file");
+  if (enabled && mappings.length === 0)
+    throw new Error(
+      "--explicit-turn-recovery requires one or more --explicit-turn SPEC|TURN|TOTAL|USD|BRL",
+    );
+  return mappings;
+}
+
+// This deliberately accepts no temporal heuristic.  A recovery is useful only
+// when a human supplies the expected SPEC-to-turn mapping and every identity
+// boundary independently agrees with the persisted Run.
+export function planExplicitTurnRecovery({ run, segments, mappings }) {
+  const runId = run?.started?.run_id;
+  const finished = run?.records?.find((record) => recordType(record) === "run.finished");
+  const usedKeys = new Set(
+    run.usage.filter((usage) => usage.source_segment_key).map((usage) => usage.source_segment_key),
+  );
+  const problems = [];
+  if (!runId || !finished) problems.push("run-not-finished");
+  if (!run?.started?.client_thread_id) problems.push("run-client-thread-unavailable");
+  if (!Array.isArray(mappings) || mappings.length === 0) problems.push("explicit-mapping-required");
+  const turnIds = new Set();
+  const recovered = [];
+  for (const mapping of mappings ?? []) {
+    if (!mapping.spec_id || !mapping.turn_id) {
+      problems.push("mapping-spec-and-turn-required");
+      continue;
+    }
+    if (turnIds.has(mapping.turn_id)) {
+      problems.push("duplicate-explicit-turn");
+      continue;
+    }
+    turnIds.add(mapping.turn_id);
+    const matches = segments.filter(
+      (segment) =>
+        segment.internal_turn_ids?.includes(mapping.turn_id) || segment.turn_id === mapping.turn_id,
+    );
+    if (matches.length !== 1) {
+      problems.push(
+        matches.length === 0
+          ? `turn-not-found:${mapping.turn_id}`
+          : `turn-ambiguous:${mapping.turn_id}`,
+      );
+      continue;
+    }
+    const segment = matches[0];
+    if (segment.session_agent_path !== run.started.client_thread_id)
+      problems.push(`session-agent-path-mismatch:${mapping.turn_id}`);
+    if (segment.model !== run.started.model || segment.effort !== run.started.reasoning_effort)
+      problems.push(`model-effort-mismatch:${mapping.turn_id}`);
+    if (usedKeys.has(segment.key)) problems.push(`turn-already-used:${mapping.turn_id}`);
+    if (!segment.finished_at) problems.push(`turn-not-finished:${mapping.turn_id}`);
+    if (!segment.raw?.includes(mapping.spec_id))
+      problems.push(`spec-evidence-missing:${mapping.turn_id}`);
+    const tokens = aggregate(segment);
+    if (mapping.total !== undefined && tokens.total !== mapping.total)
+      problems.push(`token-total-mismatch:${mapping.turn_id}`);
+    recovered.push({ mapping, segment, tokens });
+  }
+  return {
+    run_id: runId,
+    eligible: problems.length === 0 && recovered.length === mappings.length,
+    reasons: problems,
+    turns: recovered.map(({ mapping, segment, tokens }) => ({
+      spec_id: mapping.spec_id,
+      turn_id: mapping.turn_id,
+      source_segment_key: segment.key,
+      source_started_at: segment.started_at,
+      source_finished_at: segment.finished_at,
+      tokens,
+    })),
+    recovered,
+  };
+}
+
+export async function applyExplicitTurnRecovery({ run, plan }) {
+  if (!plan.eligible)
+    throw new Error(`Explicit recovery is not eligible: ${plan.reasons.join(", ")}`);
+  const finished = run.records.find((record) => recordType(record) === "run.finished");
+  const superseded = usageStatus(run.usage).effective.at(-1);
+  if (!superseded) throw new Error("Explicit recovery needs a supersedable effective usage event");
+  const sequence = run.records.length + 1;
+  const events = plan.recovered.map(({ mapping, segment, tokens }, index) => ({
+    schema_version: 2,
+    event_id: `${run.started.run_id}:explicit-turn-recovery:${String(sequence + index).padStart(6, "0")}`,
+    run_id: run.started.run_id,
+    sequence: sequence + index,
+    occurred_at: segment.finished_at,
+    type: "usage.recorded",
+    phase: recordPhase(finished),
+    activity_kind: "retrospective_explicit_turn_recovery",
+    classification_source: "explicit",
+    tokens: { ...tokens, source: "provider_reported" },
+    cost: { usd: mapping.usd, brl: mapping.brl },
+    provider: run.started.provider ?? "openai",
+    model: segment.model,
+    source_segment_key: segment.key,
+    attributed_spec_id: mapping.spec_id,
+    supersedes_event_id: index === 0 ? superseded.event_id : null,
+    retrospective_correction: true,
+    source_occurred_at: segment.finished_at,
+    source_started_at: segment.started_at,
+    source_finished_at: segment.finished_at,
+    runtime: { reasoning_effort: segment.effort, service_tier: segment.service_tier },
+  }));
+  await appendExplicitTurnRecovery(run.file, run.records, events);
+  return events;
+}
+
+// Kept separate from the general reconcile path: it only normalizes fields
+// emitted by this explicit recovery writer, and only when the same scoped
+// command is being resumed after an interrupted projection check.
+export async function normalizeExplicitTurnRecoverySchema(file, expectedRecords, mappings = []) {
+  const specByTurn = new Map(mappings.map((mapping) => [mapping.turn_id, mapping.spec_id]));
+  const changed = expectedRecords.some((record) => {
+    const usage = usageView(record);
+    return (
+      usage?.activity_kind === "retrospective_explicit_turn_recovery" &&
+      (usage.classification_source !== "explicit" ||
+        "explicit_turn_recovery" in usage ||
+        "explicit_spec_id" in usage ||
+        usage.attributed_spec_id === undefined)
+    );
+  });
+  if (!changed) return expectedRecords;
+  const lockPath = `${file}.lock`;
+  const handle = await open(lockPath, "wx");
+  await handle.close();
+  try {
+    const persisted = jsonLines(await readFile(file, "utf8"));
+    const ids = (records) => records.map((record) => record?.event_id ?? record?.[2]);
+    if (
+      persisted.length !== expectedRecords.length ||
+      ids(persisted).some((id, index) => id !== ids(expectedRecords)[index])
+    )
+      throw new Error("Run history changed before explicit recovery schema normalization");
+    let recoveryIndex = 0;
+    const normalized = persisted.map((record) => {
+      const usage = usageView(record);
+      if (usage?.activity_kind !== "retrospective_explicit_turn_recovery") return record;
+      const { explicit_turn_recovery, explicit_spec_id, ...rest } = usage;
+      const recoveredTurn = [...specByTurn.keys()].find((turn) =>
+        rest.source_segment_key?.includes(turn),
+      );
+      const mappedSpecId = mappings[recoveryIndex++]?.spec_id;
+      return {
+        ...rest,
+        classification_source: "explicit",
+        ...(typeof rest.attributed_spec_id === "string"
+          ? {}
+          : typeof explicit_spec_id === "string"
+            ? { attributed_spec_id: explicit_spec_id }
+            : recoveredTurn
+              ? { attributed_spec_id: specByTurn.get(recoveredTurn) }
+              : typeof mappedSpecId === "string"
+                ? { attributed_spec_id: mappedSpecId }
+                : {}),
+      };
+    });
+    const temporary = `${file}.explicit-recovery-schema.tmp`;
+    await writeFile(
+      temporary,
+      `${normalized.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, file);
+    return normalized;
+  } finally {
+    await rm(lockPath, { force: true });
+  }
+}
+
+export async function appendExplicitTurnRecovery(file, expectedRecords, events) {
+  if (!Array.isArray(events) || events.length === 0)
+    throw new Error("Explicit recovery events required");
+  const lockPath = `${file}.lock`;
+  const handle = await open(lockPath, "wx");
+  await handle.close();
+  try {
+    const persisted = jsonLines(await readFile(file, "utf8"));
+    const ids = (records) => records.map((record) => record?.event_id ?? record?.[2]);
+    if (
+      persisted.length !== expectedRecords.length ||
+      ids(persisted).some((id, index) => id !== ids(expectedRecords)[index])
+    )
+      throw new Error("Run history changed before explicit recovery");
+    const finishIndex = persisted.findIndex((record) => recordType(record) === "run.finished");
+    if (finishIndex < 0) throw new Error("Explicit recovery requires run.finished");
+    const before = persisted.slice(0, finishIndex);
+    const finish = persisted[finishIndex];
+    const after = persisted.slice(finishIndex + 1);
+    const updated = [...before, ...after, ...events, finish].map((record, index) =>
+      withSequence(record, index + 1),
+    );
+    const temporary = `${file}.explicit-recovery.tmp`;
+    await writeFile(
+      temporary,
+      `${updated.map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rename(temporary, file);
+  } finally {
+    await rm(lockPath, { force: true });
+  }
+}

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

@@ -116,12 +116,15 @@ 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;
+  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) {
@@ -183,11 +186,13 @@ export function duplicateUsageAssignments(runs) {
   return [...groups.values()]
     .filter((group) => new Set(group.map(({ run }) => run.started.run_id)).size > 1)
     .map((group) =>
-      [...group].sort((left, right) =>
+      [...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),
       ),
     );
 }
@@ -238,7 +243,20 @@ export function exactCompletedSegment(started, segments) {
   if (!started?.client_turn_id) return { segment: null, ambiguous: false };
   const runStartedAt = Date.parse(started.occurred_at ?? "");
   const matches = segments.filter((segment) => {
-    if (segment.turn_id !== started.client_turn_id || !segment.finished_at) return false;
+    // Older Codex sub-runs can persist the internal turn id exposed in a
+    // response item's metadata instead of the enclosing task_started id. It
+    // is an observed identity for this exact local interval, never a token
+    // matching heuristic.
+    const observedInternalTurnIds = Array.isArray(segment.internal_turn_ids)
+      ? segment.internal_turn_ids
+      : [];
+    if (
+      (segment.turn_id !== started.client_turn_id &&
+        !observedInternalTurnIds.includes(started.client_turn_id)) ||
+      !segment.finished_at
+    ) {
+      return false;
+    }
     const segmentFinishedAt = Date.parse(segment.finished_at);
     return (
       Number.isFinite(runStartedAt) &&
@@ -325,6 +343,7 @@ export async function loadSegments(workspace, sessionFiles = null) {
     let canonicalSessionMetaSeen = false;
     let workspaceMatches = false;
     let sessionId = null;
+    let sessionAgentPath = null;
     let current = null;
     let index = 0;
     let model = null;
@@ -360,6 +379,16 @@ export async function loadSegments(workspace, sessionFiles = null) {
         canonicalSessionMetaSeen = true;
         workspaceMatches = normalized(payload.cwd) === normalized(workspace);
         sessionId = nextSessionId;
+        const declaredAgentPath =
+          typeof payload.agent_path === "string"
+            ? payload.agent_path
+            : typeof payload?.source?.subagent?.thread_spawn?.agent_path === "string"
+              ? payload.source.subagent.thread_spawn.agent_path
+              : null;
+        // A child rollout may embed its parent session metadata immediately
+        // after its own. Retain the child identity rather than downgrading to
+        // the parent metadata that cannot identify the subagent.
+        sessionAgentPath = declaredAgentPath ?? sessionAgentPath;
       }
       if (!workspaceMatches) continue;
       const settings = payload?.type === "thread_settings_applied" ? payload.thread_settings : null;
@@ -388,12 +417,14 @@ export async function loadSegments(workspace, sessionFiles = null) {
           key: `${normalized(file)}#${index}`,
           file,
           session_id: sessionId,
+          session_agent_path: sessionAgentPath,
           turn_id: typeof payload.turn_id === "string" ? payload.turn_id : null,
           started_at: record.timestamp ?? null,
           finished_at: null,
           model,
           effort,
           service_tier: serviceTier,
+          internal_turn_ids: [],
           usage: [],
           raw: [],
         };
@@ -417,12 +448,27 @@ export async function loadSegments(workspace, sessionFiles = null) {
         }
       }
       if (!current) continue;
+      const internalTurnId = payload?.internal_chat_message_metadata_passthrough?.turn_id;
+      if (
+        typeof internalTurnId === "string" &&
+        !current.internal_turn_ids.includes(internalTurnId)
+      ) {
+        current.internal_turn_ids.push(internalTurnId);
+      }
       if (line.includes("RUN-") || line.includes("TASK-")) current.raw.push(line);
       if (payload?.type === "task_complete") {
         current.finished_at = record.timestamp ?? null;
         if (current.usage.length) segments.push(current);
         current = null;
       }
+      if (current && payload?.type === "turn_aborted" && payload.turn_id === current.turn_id) {
+        // An interrupted Codex turn is still an observed terminal boundary.
+        // Preserve its collected token snapshots, but never fabricate a later
+        // finish from the Run history or wall clock.
+        current.finished_at = record.timestamp ?? null;
+        if (current.usage.length) segments.push(current);
+        current = null;
+      }
     }
     if (current?.usage.length) segments.push(current);
   }