cctally 1.67.1 → 1.69.0

package/bin/_lib_jsonl.py

@@ -22,12 +22,15 @@ from __future__ import annotations
 
 import datetime as dt
 import json
+import math
 import pathlib
 import re
 import sys
 from dataclasses import dataclass, field
 from typing import Any
 
+from _lib_source_identity import canonical_identity_from_root_key
+
 
 def _eprint(*args: Any) -> None:
     print(*args, file=sys.stderr)
@@ -336,6 +339,72 @@ class _CodexIterState:
     lines_malformed: int = 0
     token_events_skipped: int = 0
     skip_reasons: dict = field(default_factory=dict)
+    thread: "CodexThreadMetadata | None" = None
+
+
+@dataclass(frozen=True)
+class CodexThreadMetadata:
+    """Source facts established by one ``session_meta`` physical record."""
+    source_root_key: str | None
+    source_path: str
+    native_thread_id: str | None
+    root_thread_id: str | None
+    parent_thread_id: str | None
+    conversation_key: str | None
+    cwd: str | None
+    git_json: str | None
+    source_kind: str | None
+    thread_source_json: str | None
+    model_provider: str | None
+    context_window: int | None
+
+
+@dataclass(frozen=True)
+class CodexQuotaObservation:
+    """One validated native quota window from a physical rollout record."""
+    source: str
+    source_root_key: str | None
+    source_path: str
+    line_offset: int
+    captured_at_utc: str
+    observed_slot: str
+    logical_limit_key: str
+    limit_id: str | None
+    limit_name: str | None
+    window_minutes: int
+    used_percent: float
+    resets_at_utc: str
+    plan_type: str | None
+    individual_limit_json: str | None
+    reached_type: str | None
+
+
+@dataclass(frozen=True)
+class CodexPhysicalEvent:
+    """Complete canonical payload retained for one valid JSON object line."""
+    source_path: str
+    line_offset: int
+    source_root_key: str | None
+    conversation_key: str | None
+    native_thread_id: str | None
+    root_thread_id: str | None
+    parent_thread_id: str | None
+    timestamp_utc: str | None
+    record_type: str | None
+    event_type: str | None
+    turn_id: str | None
+    call_id: str | None
+    payload_json: str
+
+
+@dataclass(frozen=True)
+class CodexFusedEmission:
+    """All source-derived facts emitted after parsing one physical record once."""
+    line_offset: int
+    event: CodexPhysicalEvent
+    accounting: CodexEntry | None
+    quotas: tuple[CodexQuotaObservation, ...]
+    thread: CodexThreadMetadata | None
 
 
 def _codex_skip(state: "_CodexIterState", reason: str) -> None:
@@ -343,195 +412,493 @@ def _codex_skip(state: "_CodexIterState", reason: str) -> None:
     state.skip_reasons[reason] = state.skip_reasons.get(reason, 0) + 1
 
 
-def _iter_codex_jsonl_entries_with_offsets(
+_QUOTA_ENVELOPE_FIELDS = frozenset((
+    "credits", "plan_type", "limit_id", "limit_name", "individual_limit",
+    "rate_limit_reached_type",
+))
+
+
+def _codex_string(value: object) -> str | None:
+    return value if isinstance(value, str) and value.strip() else None
+
+
+def _codex_canonical_json(value: object) -> str:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False,
+                      allow_nan=False)
+
+
+def _parse_codex_timestamp(value: object) -> dt.datetime | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    try:
+        parsed = dt.datetime.fromisoformat(value.strip().replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return parsed
+
+
+def _format_codex_timestamp(value: dt.datetime) -> str:
+    return value.astimezone(dt.timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def _finite_number(value: object) -> float | None:
+    # Quota JSON fields are typed numerics.  Do not coerce strings: a malformed
+    # direct value must yield to a valid typed fallback in payload.info.
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    try:
+        number = float(value)
+    except (TypeError, ValueError, OverflowError):
+        return None
+    return number if math.isfinite(number) else None
+
+
+def _json_value_is_finite(value: object) -> bool:
+    """Whether a decoded JSON value can be serialized canonically.
+
+    ``json.loads`` rejects the literal NaN/Infinity constants through
+    ``parse_constant``, but a syntactically valid exponent such as ``1e400``
+    is decoded as ``float('inf')``.  Reject it before a physical event reaches
+    canonical serialization with ``allow_nan=False``.
+    """
+    if isinstance(value, float):
+        return math.isfinite(value)
+    if isinstance(value, dict):
+        return all(_json_value_is_finite(item) for item in value.values())
+    if isinstance(value, list):
+        return all(_json_value_is_finite(item) for item in value)
+    return True
+
+
+def _positive_whole_number(value: object) -> int | None:
+    number = _finite_number(value)
+    if number is None or number <= 0 or not number.is_integer():
+        return None
+    return int(number)
+
+
+def _quota_reset_at(value: object) -> str | None:
+    numeric = _finite_number(value)
+    if numeric is not None:
+        try:
+            return _format_codex_timestamp(
+                dt.datetime.fromtimestamp(numeric, tz=dt.timezone.utc)
+            )
+        except (OverflowError, OSError, ValueError):
+            return None
+    parsed = _parse_codex_timestamp(value)
+    return _format_codex_timestamp(parsed) if parsed is not None else None
+
+
+def _first_valid_string(*values: object) -> str | None:
+    for value in values:
+        string = _codex_string(value)
+        if string is not None:
+            return string
+    return None
+
+
+def _canonical_container(value: object) -> str | None:
+    if not isinstance(value, (dict, list)):
+        return None
+    return _codex_canonical_json(value)
+
+
+def _thread_metadata_from_session_meta(
+    payload: dict[str, Any], path_str: str, source_root_key: str | None,
+) -> CodexThreadMetadata:
+    accounting_id = _codex_string(payload.get("id"))
+    native_thread_id = _codex_string(payload.get("session_id")) or accounting_id
+    root_thread_id = _codex_string(payload.get("thread_source"))
+    parent_thread_id = _codex_string(payload.get("forked_from_id"))
+    conversation_key = None
+    if native_thread_id is not None and root_thread_id is not None:
+        conversation_key = canonical_identity_from_root_key(
+            "codex", "conversation", source_root_key, native_thread_id, root_thread_id
+        )
+    return CodexThreadMetadata(
+        source_root_key=source_root_key,
+        source_path=path_str,
+        native_thread_id=native_thread_id,
+        root_thread_id=root_thread_id,
+        parent_thread_id=parent_thread_id,
+        conversation_key=conversation_key,
+        cwd=_codex_string(payload.get("cwd")),
+        git_json=_canonical_container(payload.get("git")),
+        source_kind=_codex_string(payload.get("source")),
+        thread_source_json=_canonical_container(payload.get("thread_source")),
+        model_provider=_codex_string(payload.get("model_provider")),
+        context_window=_positive_whole_number(payload.get("context_window")),
+    )
+
+
+def _first_valid_individual_limit_json(
+    direct: dict[str, Any], fallback: dict[str, Any],
+) -> str | None:
+    for envelope in (direct, fallback):
+        value = envelope.get("individual_limit")
+        if isinstance(value, dict):
+            return _codex_canonical_json(value)
+        if _finite_number(value) is not None:
+            return _codex_canonical_json(value)
+    return None
+
+
+def _first_valid_quota_number(
+    direct: dict[str, Any], fallback: dict[str, Any], key: str,
+    *, minimum: float | None = None, maximum: float | None = None,
+) -> float | None:
+    for window in (direct, fallback):
+        number = _finite_number(window.get(key))
+        if number is None:
+            continue
+        if minimum is not None and number < minimum:
+            continue
+        if maximum is not None and number > maximum:
+            continue
+        return number
+    return None
+
+
+def _first_valid_window_minutes(
+    direct: dict[str, Any], fallback: dict[str, Any],
+) -> int | None:
+    for window in (direct, fallback):
+        minutes = _positive_whole_number(window.get("window_minutes"))
+        if minutes is not None:
+            return minutes
+    return None
+
+
+def _first_valid_reset_at(
+    direct: dict[str, Any], fallback: dict[str, Any],
+) -> str | None:
+    for window in (direct, fallback):
+        reset_at = _quota_reset_at(window.get("resets_at"))
+        if reset_at is not None:
+            return reset_at
+    return None
+
+
+def _codex_logical_limit_key(
+    source_root_key: str | None, limit_id: str | None, observed_slot: str,
+    window_minutes: int,
+) -> str:
+    return _codex_canonical_json({
+        "limitId": limit_id,
+        "observedSlot": observed_slot,
+        "source": "codex",
+        "sourceRootKey": source_root_key,
+        "windowMinutes": window_minutes,
+    })
+
+
+def _codex_quota_observations(
+    obj: dict[str, Any], payload: dict[str, Any], path_str: str, line_offset: int,
+    source_root_key: str | None,
+) -> tuple[CodexQuotaObservation, ...]:
+    captured_at = _parse_codex_timestamp(obj.get("timestamp"))
+    if captured_at is None:
+        return ()
+    direct = payload.get("rate_limits")
+    info = payload.get("info")
+    fallback = info.get("rate_limits") if isinstance(info, dict) else None
+    direct = direct if isinstance(direct, dict) else {}
+    fallback = fallback if isinstance(fallback, dict) else {}
+    if not direct and not fallback:
+        return ()
+
+    slots = sorted({
+        slot for envelope in (direct, fallback) for slot, value in envelope.items()
+        if slot not in _QUOTA_ENVELOPE_FIELDS and isinstance(value, dict)
+    })
+    observations: list[CodexQuotaObservation] = []
+    for slot in slots:
+        direct_window = direct.get(slot)
+        fallback_window = fallback.get(slot)
+        direct_window = direct_window if isinstance(direct_window, dict) else {}
+        fallback_window = fallback_window if isinstance(fallback_window, dict) else {}
+        used_percent = _first_valid_quota_number(
+            direct_window, fallback_window, "used_percent", minimum=0.0, maximum=100.0
+        )
+        window_minutes = _first_valid_window_minutes(direct_window, fallback_window)
+        resets_at_utc = _first_valid_reset_at(direct_window, fallback_window)
+        if used_percent is None or window_minutes is None or resets_at_utc is None:
+            continue
+        limit_id = _first_valid_string(
+            direct.get("limit_id"), fallback.get("limit_id")
+        )
+        observations.append(CodexQuotaObservation(
+            source="codex",
+            source_root_key=source_root_key,
+            source_path=path_str,
+            line_offset=line_offset,
+            captured_at_utc=_format_codex_timestamp(captured_at),
+            observed_slot=slot,
+            logical_limit_key=_codex_logical_limit_key(
+                source_root_key, limit_id, slot, window_minutes
+            ),
+            limit_id=limit_id,
+            limit_name=_first_valid_string(
+                direct.get("limit_name"), fallback.get("limit_name")
+            ),
+            window_minutes=window_minutes,
+            used_percent=used_percent,
+            resets_at_utc=resets_at_utc,
+            plan_type=_first_valid_string(
+                direct.get("plan_type"), fallback.get("plan_type")
+            ),
+            individual_limit_json=_first_valid_individual_limit_json(direct, fallback),
+            reached_type=_first_valid_string(
+                direct.get("rate_limit_reached_type"),
+                fallback.get("rate_limit_reached_type"),
+            ),
+        ))
+    return tuple(observations)
+
+
+def _reject_nonfinite_json_constant(value: str) -> None:
+    raise ValueError(f"non-finite JSON constant: {value}")
+
+
+def _seed_codex_iter_state(
+    state: _CodexIterState, initial_session_id: str | None,
+    initial_model: str | None, initial_total_tokens: int,
+) -> None:
+    if state.session_id is None and initial_session_id is not None:
+        state.session_id = initial_session_id
+    if state.model is None and initial_model is not None:
+        state.model = initial_model
+    if state.total_tokens == 0 and initial_total_tokens:
+        state.total_tokens = int(initial_total_tokens)
+
+
+def _event_from_record(
+    obj: dict[str, Any], path_str: str, line_offset: int,
+    source_root_key: str | None, thread: CodexThreadMetadata | None,
+) -> CodexPhysicalEvent:
+    payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+    record_type = _codex_string(obj.get("type")) or _codex_string(obj.get("record_type"))
+    return CodexPhysicalEvent(
+        source_path=path_str,
+        line_offset=line_offset,
+        source_root_key=source_root_key,
+        conversation_key=thread.conversation_key if thread is not None else None,
+        native_thread_id=thread.native_thread_id if thread is not None else None,
+        root_thread_id=thread.root_thread_id if thread is not None else None,
+        parent_thread_id=thread.parent_thread_id if thread is not None else None,
+        timestamp_utc=(
+            _format_codex_timestamp(timestamp)
+            if (timestamp := _parse_codex_timestamp(obj.get("timestamp"))) is not None
+            else None
+        ),
+        record_type=record_type,
+        event_type=_codex_string(payload.get("type")),
+        turn_id=_codex_string(payload.get("turn_id")),
+        call_id=_codex_string(payload.get("call_id")),
+        payload_json=_codex_canonical_json(obj),
+    )
+
+
+def _accounting_from_record(
+    obj: dict[str, Any], payload: dict[str, Any], path_str: str,
+    state: _CodexIterState, last_total_tokens: int,
+    filename_uuid: str | None, filename_session_id_warned: bool,
+) -> tuple[CodexEntry | None, int, bool]:
+    if obj.get("type") != "event_msg" or payload.get("type") != "token_count":
+        return None, last_total_tokens, filename_session_id_warned
+    info = payload.get("info")
+    if info is None:
+        return None, last_total_tokens, filename_session_id_warned
+    if not isinstance(info, dict):
+        _codex_skip(state, "info-non-dict")
+        return None, last_total_tokens, filename_session_id_warned
+    last_token_usage = info.get("last_token_usage")
+    if not isinstance(last_token_usage, dict):
+        _codex_skip(state, "no-last-token-usage")
+        return None, last_total_tokens, filename_session_id_warned
+
+    total_token_usage = info.get("total_token_usage")
+    if isinstance(total_token_usage, dict):
+        try:
+            cumulative = int(total_token_usage.get("total_tokens") or 0)
+        except (TypeError, ValueError):
+            cumulative = 0
+        if cumulative <= last_total_tokens:
+            return None, last_total_tokens, filename_session_id_warned
+    else:
+        cumulative = None
+
+    timestamp = _parse_codex_timestamp(obj.get("timestamp"))
+    if timestamp is None:
+        _codex_skip(state, "bad-timestamp")
+        return None, last_total_tokens, filename_session_id_warned
+    session_id = state.session_id
+    if session_id is None:
+        session_id = filename_uuid
+        if session_id is not None and not filename_session_id_warned:
+            _eprint(
+                f"[codex] session_meta not seen in {path_str}; "
+                f"falling back to filename UUID {session_id}"
+            )
+            filename_session_id_warned = True
+        if session_id is None:
+            _codex_skip(state, "no-session-id")
+            return None, last_total_tokens, filename_session_id_warned
+
+    def token_count(key: str) -> int:
+        try:
+            return int(last_token_usage.get(key) or 0)
+        except (TypeError, ValueError):
+            return 0
+
+    entry = CodexEntry(
+        timestamp=timestamp,
+        session_id=session_id,
+        model=state.model or "unknown",
+        input_tokens=token_count("input_tokens"),
+        cached_input_tokens=token_count("cached_input_tokens"),
+        output_tokens=token_count("output_tokens"),
+        reasoning_output_tokens=token_count("reasoning_output_tokens"),
+        total_tokens=token_count("total_tokens"),
+        source_path=path_str,
+    )
+    if cumulative is not None:
+        state.total_tokens = cumulative
+        last_total_tokens = cumulative
+    return entry, last_total_tokens, filename_session_id_warned
+
+
+def _iter_codex_fused_records_with_offsets(
     fh,
     path_str: str,
     *,
     initial_session_id: str | None = None,
     initial_model: str | None = None,
     initial_total_tokens: int = 0,
+    source_root_key: str | None = None,
     state: _CodexIterState | None = None,
 ):
-    """Yield (line_offset, CodexEntry) for each billable `token_count` event.
-
-    Maintains per-file state (session_id, model) as records are streamed.
-    Callers performing a delta resume from non-zero byte offset should pass
-    the previously-observed session_id/model as initial_session_id and
-    initial_model so attribution stays correct even if the new byte range
-    contains no fresh session_meta / turn_context record.
-
-    If `state` is supplied it is updated in-place on every `session_meta`
-    / `turn_context` record regardless of whether any subsequent
-    `token_count` actually yields. This lets callers observe the iterator's
-    terminal state even when the delta window ends on a metadata record —
-    otherwise `last_model` would silently persist a stale value and the
-    next resume would mis-attribute the first post-resume token_count.
-
-    Skips token_count events with payload.info == None (rate-limit-only
-    events). Falls back to filename-derived session_id with a one-shot warning
-    if session_meta is never observed.
-
-    Codex CLI emits multiple `token_count` events per completed turn (UI/
-    turn_context updates re-emit the same `last_token_usage` while the
-    cumulative `info.total_token_usage.total_tokens` stays flat). To avoid
-    double-counting, we track the cumulative total across yields and skip
-    any event whose cumulative total is not strictly greater than the
-    previously-seen cumulative. Callers doing delta resumes should pass the
-    last persisted cumulative as `initial_total_tokens`. If `total_token_usage`
-    is missing or non-dict (older Codex builds), we fall back to yielding
-    unconditionally — preserving legacy behavior on those rollouts.
-
-    Readline()+tell() is used rather than `for line in fh` so byte offsets
-    are accurate for resume-from-offset after partial ingests. Partial-tail
-    lines (no trailing \\n) trigger a seek-back so the next sync re-reads
-    the line once the newline is flushed.
+    """Yield typed facts for every complete, valid Codex JSONL object.
+
+    Binary readers retain physical byte offsets and strictly reject invalid UTF-8,
+    non-finite JSON constants, and non-object JSON.  The mutable state carries
+    the shipped accounting resume contract alongside the latest thread facts.
     """
     if state is None:
         state = _CodexIterState()
-    # Seed the tracker from the kwargs. Kwargs take priority only when the
-    # caller-supplied state has no value yet — this preserves the existing
-    # contract for callers that pass kwargs without a state object, while
-    # letting callers who DO pass a pre-populated state see it honored.
-    if state.session_id is None and initial_session_id is not None:
-        state.session_id = initial_session_id
-    if state.model is None and initial_model is not None:
-        state.model = initial_model
-    # #279 S3 F1: the state carries the REAL dedup watermark. Seeding
-    # precedence mirrors session_id/model: a caller-supplied NON-ZERO state
-    # wins; the kwarg seeds otherwise. (total_tokens has no None sentinel —
-    # 0 IS the unset value; a genuine 0 watermark and "unset" are the same
-    # thing: both mean "dedupe against nothing".)
-    if state.total_tokens == 0 and initial_total_tokens:
-        state.total_tokens = int(initial_total_tokens)
-    last_total_tokens: int = state.total_tokens
-    # Suppress the filename-UUID fallback warning when we already have a
-    # seeded session_id (delta resume path). Without this, every resume
-    # into a slice of the file that doesn't re-observe session_meta would
-    # noisily warn even though attribution is correct.
+    _seed_codex_iter_state(state, initial_session_id, initial_model, initial_total_tokens)
+    last_total_tokens = state.total_tokens
     filename_session_id_warned = state.session_id is not None
     filename_uuid_match = _CODEX_FILENAME_UUID_RE.search(path_str)
     filename_uuid = filename_uuid_match.group(1) if filename_uuid_match else None
 
     while True:
-        offset = fh.tell()
+        line_offset = fh.tell()
         line = fh.readline()
         if not line:
             return
-        if not line.endswith("\n"):
-            fh.seek(offset)
+        if isinstance(line, bytes):
+            complete = line.endswith(b"\n")
+            text: str | None
+            try:
+                text = line.decode("utf-8")
+            except UnicodeDecodeError:
+                text = None
+        else:
+            complete = line.endswith("\n")
+            text = line
+        if not complete:
+            fh.seek(line_offset)
             return
-        stripped = line.strip()
+        if text is None:
+            state.lines_seen += 1
+            state.lines_malformed += 1
+            continue
+        stripped = text.strip()
         if not stripped:
             continue
-        state.lines_seen += 1  # #279 S2 F1: non-blank lines (malformed included)
+        state.lines_seen += 1
         try:
-            obj = json.loads(stripped)
-        except json.JSONDecodeError:
+            obj = json.loads(stripped, parse_constant=_reject_nonfinite_json_constant)
+        except (json.JSONDecodeError, ValueError, TypeError):
             state.lines_malformed += 1
             continue
-
-        rtype = obj.get("type")
-        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
-
-        if rtype == "session_meta":
-            sid = payload.get("id")
-            if isinstance(sid, str) and sid:
-                state.session_id = sid
-            continue
-
-        if rtype == "turn_context":
-            m = payload.get("model")
-            if isinstance(m, str) and m.strip():
-                state.model = m.strip()
-            continue
-
-        if rtype != "event_msg":
-            continue
-
-        if payload.get("type") != "token_count":
-            continue
-        info = payload.get("info")
-        if info is None:
-            continue  # rate-limit-only event — normal, not drift
-        if not isinstance(info, dict):
-            _codex_skip(state, "info-non-dict")
+        if not isinstance(obj, dict):
+            state.lines_malformed += 1
             continue
-        ltu = info.get("last_token_usage")
-        if not isinstance(ltu, dict):
-            _codex_skip(state, "no-last-token-usage")
+        if not _json_value_is_finite(obj):
+            state.lines_malformed += 1
             continue
 
-        # Dedupe re-emitted token_count events. Codex re-emits `last_token_usage`
-        # on UI/turn_context updates with a flat `total_token_usage.total_tokens`;
-        # only yield once per actual turn by requiring the cumulative to strictly
-        # advance. If `total_token_usage` is missing or non-dict (older Codex
-        # builds), skip the guard and yield — preserving legacy behavior.
-        ttu = info.get("total_token_usage")
-        if isinstance(ttu, dict):
-            try:
-                cumulative = int(ttu.get("total_tokens") or 0)
-            except (TypeError, ValueError):
-                cumulative = 0
-            if cumulative <= last_total_tokens:
-                continue
-        else:
-            cumulative = None  # type: ignore[assignment]
+        payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
+        thread_update = None
+        if obj.get("type") == "session_meta":
+            session_id = _codex_string(payload.get("id"))
+            if session_id is not None:
+                state.session_id = session_id
+            thread_update = _thread_metadata_from_session_meta(
+                payload, path_str, source_root_key
+            )
+            state.thread = thread_update
+        elif obj.get("type") == "turn_context":
+            model = _codex_string(payload.get("model"))
+            if model is not None:
+                state.model = model.strip()
+
+        event = _event_from_record(
+            obj, path_str, line_offset, source_root_key, state.thread
+        )
+        accounting, last_total_tokens, filename_session_id_warned = _accounting_from_record(
+            obj, payload, path_str, state, last_total_tokens, filename_uuid,
+            filename_session_id_warned,
+        )
+        quotas = _codex_quota_observations(
+            obj, payload, path_str, line_offset, source_root_key
+        )
+        yield CodexFusedEmission(
+            line_offset=line_offset,
+            event=event,
+            accounting=accounting,
+            quotas=quotas,
+            thread=thread_update,
+        )
 
-        ts_raw = obj.get("timestamp")
-        if not isinstance(ts_raw, str) or not ts_raw.strip():
-            _codex_skip(state, "bad-timestamp")
-            continue
-        try:
-            ts = dt.datetime.fromisoformat(ts_raw.strip().replace("Z", "+00:00"))
-            if ts.tzinfo is None:
-                ts = ts.replace(tzinfo=dt.timezone.utc)
-        except ValueError:
-            _codex_skip(state, "bad-timestamp")
-            continue
 
-        session_id = state.session_id
-        if session_id is None:
-            session_id = filename_uuid
-            if session_id is not None and not filename_session_id_warned:
-                _eprint(
-                    f"[codex] session_meta not seen in {path_str}; "
-                    f"falling back to filename UUID {session_id}"
-                )
-                filename_session_id_warned = True
-            if session_id is None:
-                # No session_meta and no parseable filename UUID — skip row.
-                _codex_skip(state, "no-session-id")
-                continue
-
-        model = state.model or "unknown"
-
-        def _int(key: str) -> int:
-            v = ltu.get(key)
-            try:
-                return int(v or 0)
-            except (TypeError, ValueError):
-                return 0
-
-        yield (
-            offset,
-            CodexEntry(
-                timestamp=ts,
-                session_id=session_id,
-                model=model,
-                input_tokens=_int("input_tokens"),
-                cached_input_tokens=_int("cached_input_tokens"),
-                output_tokens=_int("output_tokens"),
-                reasoning_output_tokens=_int("reasoning_output_tokens"),
-                total_tokens=_int("total_tokens"),
-                source_path=path_str,
-            ),
-        )
-        # Advance the cumulative watermark only after a successful yield so
-        # resume-from-offset continues to dedupe against the last counted turn.
-        # #279 S3 F1: stamp the state too — after the iterator drains,
-        # state.total_tokens IS the guard's terminal watermark, which the
-        # caller persists (the old reconstructed initial+Σ(per-turn) sum could
-        # diverge from it and double-count/skip on resume).
-        if isinstance(ttu, dict) and cumulative is not None:
-            last_total_tokens = cumulative
-            state.total_tokens = cumulative
+def _iter_codex_jsonl_entries_with_offsets(
+    fh,
+    path_str: str,
+    *,
+    initial_session_id: str | None = None,
+    initial_model: str | None = None,
+    initial_total_tokens: int = 0,
+    state: _CodexIterState | None = None,
+):
+    """Compatibility wrapper exposing only existing accounting emissions."""
+    binary_fh = fh
+    text_fh = None
+    try:
+        if isinstance(fh.read(0), str) and hasattr(fh, "buffer"):
+            text_fh = fh
+            position = fh.tell()
+            fh.seek(position)
+            binary_fh = fh.buffer
+            binary_fh.seek(position)
+    except (AttributeError, OSError, TypeError):
+        pass
+    try:
+        for emission in _iter_codex_fused_records_with_offsets(
+            binary_fh,
+            path_str,
+            initial_session_id=initial_session_id,
+            initial_model=initial_model,
+            initial_total_tokens=initial_total_tokens,
+            state=state,
+        ):
+            if emission.accounting is not None:
+                yield emission.line_offset, emission.accounting
+    finally:
+        if text_fh is not None:
+            text_fh.seek(binary_fh.tell())