cdx-manager 0.25.3 → 0.25.4

package/README.md

@@ -4,7 +4,7 @@
 
 <br clear="left"/>
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.25.3-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.25.4-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **The right AI coding account, when you need it.** CDX Manager keeps your Codex and Claude accounts in separate profiles, shows which ones have quota, and helps you pick the next usable session from your terminal.
 
@@ -178,8 +178,15 @@ result. A probe overlapping the short snapshot can still report contention.
 Controller renewal does not extend the worker's copied access token; quota remains
 one controller-side account snapshot, never a worker copy. Multiple independent controllers sharing copied OAuth profiles are not
 supported. Costs and budget checks use measured worker usage and observed rollout
-models; unknown prices and delayed provider reporting retain the usual budget
-limitations. A run that outlives the access credential fails with
+models, using the same exact-thread reader and 128 MiB rollout limit as local
+isolated runs. Content-free evidence travels in supervisor frames separated from
+provider stdout; raw rollouts and credentials are never returned. Live rollout
+counters can stop an over-budget run before `turn.completed`. Unknown prices and
+delayed provider reporting retain the usual budget limitations. With `--budget`,
+measured but unpriceable usage still fails with `budget_unverifiable` (exit 125),
+even after the provider finishes, preserving the documented fail-closed guarantee.
+Provider output remains in the run artifacts; without a budget, a completed run
+keeps its provider status and unknown cost. A run that outlives the access credential fails with
 `remote_credential_expired`, requiring a new controller launch.
 
 The empty-refresh-token behavior was measured with Codex CLI 0.166.0. Real-host

package/VERSION

@@ -1 +1 @@
-0.25.3
+0.25.4

package/changelogs/CHANGELOGS_0_25_4.md

@@ -0,0 +1,14 @@
+# CDX Manager 0.25.4
+
+Release date: 2026-11-01
+
+This patch release measures remote Codex run costs from observed model evidence and applies budgets to those estimates.
+
+## Fixes
+
+- Attribute remote run costs to the model observed in Codex usage evidence rather than the requested model. Preserve that evidence in run tracking, stop runs when measured usage exceeds the budget, and report unverifiable budgets explicitly when reliable model evidence or pricing is unavailable. (#83)
+
+## Maintenance
+
+- Record tray companion checksums for v0.25.3. (`222d5127314bab4200bb13b1b364b3ab5253fb1b`)
+- Record release archive checksums for v0.25.3. (`9bac8bf616345e4348507038dc392a51eb0a360f`)

package/changelogs/CHANGELOGS_UNRELEASED.md

@@ -12,6 +12,13 @@
 - Add `cdx run --budget USD` to stop on measured estimated spend with exit code 125, `budget_exceeded`, and `error.spent_usd` in the final JSON. Share the budget across recovery attempts and failover; support detached runs and fresh budgets for continued runs without charging earlier turns.
 - Document unknown usage/prices and delayed provider reporting, including possible budget overshoot. Cover pricing, unknown costs, validation, live process termination, Claude transcript accumulation, continuation boundaries, and detached supervision in tests.
 
+## Remote run cost observations
+
+- Use the local exact-thread observation reader, usage normalization and 128 MiB rollout limit on workers; return content-free model/counter evidence before volatile storage cleanup and bind it to controller run/attempt artifacts.
+- Separate supervisor evidence frames from provider stdout, and check live rollout measurements before `turn.completed` so measured remote budget excess still stops the provider. Never price from requested models or controller-side rollouts.
+- Preserve the documented fail-closed budget guarantee: measured but unpriceable remote usage exits 125 with `budget_unverifiable`, including after provider completion. Keep provider output in artifacts; completed runs without a budget retain their actual status and unknown cost. Credential snapshots, redaction, cleanup and workspace isolation remain unchanged.
+- Cover priced remote/isolated runs, Windows transport, rollouts over 16 MiB, live budget stops, missing/inconsistent/mixed model evidence, unknown prices and completion without pricing using the fake transport.
+
 ## Remote Codex runs
 
 - Add `cdx run --remote SSH_TARGET` with controller-owned supervision, registry, history, output, costs, budgets and detached execution.

package/checksums/release-archives.json

@@ -716,6 +716,17 @@
         "x86_64-pc-windows-msvc": "ffcd4deb8b3843771659d2c6b92b003822b288329ddcf3b9a13f0f9820fa3df1",
         "x86_64-unknown-linux-musl": "2cefeea0aad5bb0acfcbc99146ffacc5c5da9386f8338e4a01541e97ccf71e07"
       }
+    },
+    "v0.25.3": {
+      "github_tarball_sha256": "34114563f0edf4d8e13d9410d6a37e4c315571a8410de607b8bc541032561a21",
+      "github_zip_sha256": "58cabe7d9d48c314e568c317893b460ca8c8853434a68ee3397e23999f823ddf",
+      "tray_assets": {
+        "aarch64-apple-darwin": "14da8f42193e78c1bfca5ac046a6a23c7ab52b4155ac9eb213bd9af09cd5e6cc",
+        "aarch64-unknown-linux-musl": "47b6988f5f361403e2c8e0c2ff5951cb758af3cde3fc6bb02f7eb718042c3027",
+        "x86_64-apple-darwin": "aac73ff0abdb76a957ebd7c143ff3ace46d6df7b08f13db922b28e76dcbc82d0",
+        "x86_64-pc-windows-msvc": "c81623ffb94b11ae7b7b28be123b49393240bb0edd31c69969ca07d7eab8dff7",
+        "x86_64-unknown-linux-musl": "6892112587c1d8c6e805a90148ec8deb6c04b5927c7ed0c18f19479d521c0ced"
+      }
     }
   }
 }

package/docs/cli.md

@@ -254,7 +254,7 @@ At or above the limit, cdx terminates the provider process tree, skips further r
 
 With `--detach`, the launch still exits successfully and includes `budget_usd`; cdx always uses its own child supervisor for budgeted runs, including when native background delegation is enabled. Inspect `cdx run-status RUN_ID --json` or `cdx run-report RUN_ID --json` for the child's final payload and budget error. `--continue-run` starts a fresh budget for the new run, including in detached mode.
 
-Conservative assumption: this is a stop based on observed, priceable usage, not a prepaid billing limit. Provider updates can arrive late or only at completion, and termination can take time, so actual spend can exceed the amount. Before the first measurement, `budget_status` is `usage_not_measured`; absence is not zero spend. Once usage is measured, missing continuation boundaries, mixed/unobserved models, and unknown prices stop further execution/recovery with exit **125**, `error.source: "cdx"`, `error.code: "budget_unverifiable"`, `budget_status: "unverifiable"`, and `cost_usd: null`. This is a measurement failure, not a claim that the dollar limit was exceeded or enforced. Supply a `CDX_TOKEN_PRICES` override for a model missing from the table. Existing profile-level `cdx set --budget` settings remain the provider-native Claude cap and apply independently.
+Conservative assumption: this is a stop based on observed, priceable usage, not a prepaid billing limit. Provider updates can arrive late or only at completion, and termination can take time, so actual spend can exceed the amount. Before the first measurement, `budget_status` is `usage_not_measured`; absence is not zero spend. Once usage is measured, missing continuation boundaries, mixed/unobserved models, and unknown prices stop further execution/recovery with exit **125**, `error.source: "cdx"`, `error.code: "budget_unverifiable"`, `budget_status: "unverifiable"`, and `cost_usd: null`. This is a measurement failure, not a claim that the dollar limit was exceeded or enforced. This fail-closed guarantee also applies to a remote agent that has already completed: the supervisor reports `failed`/125 while retaining its final output and artifacts. Without `--budget`, unknown pricing does not replace the provider's completion status. Supply a `CDX_TOKEN_PRICES` override for a model missing from the table. Existing profile-level `cdx set --budget` settings remain the provider-native Claude cap and apply independently.
 
 Every usage record, whichever path produced it, uses one set of definitions:
 
@@ -292,7 +292,7 @@ The figure uses standard public list prices, excluding Fast/priority, Batch/Flex
 
 Completed results, registry records, and history JSON include `cost_status` (`estimated` or `unknown`) and nullable `cost_reason`: `usage_not_measured`, `model_not_observed`, `model_price_unknown`, `attempt_usage_unavailable`, or `mixed_models_without_counters`. Stats include `unpriced_reasons` counts alongside `priced_runs` and `unpriced_models`. These are list-price estimates, not billing receipts. `budget_status` is `not_requested`, `usage_not_measured`, `estimated`, `exceeded`, or `unverifiable`.
 
-New headless attempts have distinct `attempt_id` values and artifact paths, including retries on the same profile. Final payloads and registry reports expose `attempts` with their individual model evidence, counters, and estimates; top-level usage describes the final attempt, while a budget-exceeded spend includes all attempts. New isolated Codex attempts mount only a fresh sessions directory from volatile `/dev/shm` storage. The supervisor reads the exact `thread.started` rollout while it exists and at closeout, requiring matching session identity, turn timestamps within this attempt, and token counters consistent with stdout. It exports `usage_evidence` containing only the stdout attempt identity, thread id, timestamp bounds, turn ids, observed models, and normalized counters; live rollout counters can establish the first measurement before `turn.completed`. No requested model, agent-authored cost report, current profile setting, prompt, message, or tool output is used as model evidence. The raw temporary sessions are removed at closeout, including cancellation and startup failure; they are never copied into persistent run artifacts. Host profiles are not mounted. Mixed serving models stay unpriced without attributable counters. Isolated continuation without comparable launch boundaries stays unmeasured rather than charging an older conversation to the new attempt.
+New headless attempts have distinct `attempt_id` values and artifact paths, including retries on the same profile. Final payloads and registry reports expose `attempts` with their individual model evidence, counters, and estimates; top-level usage describes the final attempt, while a budget-exceeded spend includes all attempts. New isolated Codex attempts mount only a fresh sessions directory from volatile `/dev/shm` storage. The supervisor reads the exact `thread.started` rollout while it exists and at closeout, requiring matching session identity, turn timestamps within this attempt, and token counters consistent with stdout. It exports `usage_evidence` containing only the stdout attempt identity, thread id, timestamp bounds, turn ids, observed models, and normalized counters; live rollout counters can establish the first measurement before `turn.completed`. No requested model, agent-authored cost report, current profile setting, prompt, message, or tool output is used as model evidence. The raw temporary sessions are removed at closeout, including cancellation and startup failure; they are never copied into persistent run artifacts. Host profiles are not mounted. Remote Codex runs ship the same observation reader and normalization code over the existing stdin bootstrap. The worker validates the exact fresh-home thread, timestamp bounds and matching counters with the local 128 MiB limit, and returns only normalized evidence through supervisor frames, separate from provider stdout. The controller attaches its own stdout path, run id and attempt id before live budget checks and final persistence; it never consults a controller profile rollout for remote usage. Worker stdout capture stays in the existing volatile private home and is deleted with it. Credentials, refresh handling and workspace mounts are unchanged. Live rollout counters can establish remote usage before `turn.completed`. Mixed serving models stay unpriced without attributable counters. Isolated continuation without comparable launch boundaries stays unmeasured rather than charging an older conversation to the new attempt.
 
 Completed run JSON and registry reports expose `usage_model` separately from the requested `model`. Pricing uses the observed model from provider output; Codex can also supply it through the exact rollout identified by `thread.started.thread_id`. Configured defaults alone never establish serving-model identity, and missing or mixed model evidence stays unpriced. `--by model` groups Claude's `[1m]` context variant with its base model while preserving the original model string and per-run pricing. New runs record this evidence automatically. To recover missing models in existing history, run:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.25.3",
+  "version": "0.25.4",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.25.3"
+version = "0.25.4"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9.2"

package/src/commands/runs.py

@@ -584,7 +584,7 @@ def _observe_headless_usage(session, run_info, baseline=None):
 
 def _budget_observation(session, paths, baseline):
     observation = _observe_headless_usage(session, paths, baseline if session["provider"] == "codex" else None)
-    if (session.get("launch") or {}).get("isolate_workspace"):
+    if paths.get("remote") or (session.get("launch") or {}).get("isolate_workspace"):
         return observation
     identifier = (extract_run_conversation_id(session["provider"], paths.get("stdout_path"))
                   or ((session.get("conversation") or {}).get("id")

package/src/remote_run.py

@@ -7,6 +7,7 @@ import os
 import pathlib
 import re
 import subprocess
+import threading
 import time
 from contextlib import contextmanager
 from datetime import datetime, timezone
@@ -82,6 +83,11 @@ def worker_input():
     # One JSON line frames the source, leaving the next line for the payload.
     directory = pathlib.Path(__file__).parent
     source = 'SANDBOX_SOURCE = ' + repr((directory / 'workspace_sandbox.py').read_text()) + '\n'
+    from .interactive_usage import MAX_TRANSCRIPT_BYTES, MAX_TRANSCRIPT_SCAN_SECONDS
+    modules = {name: (directory / (name + '.py')).read_text()
+               for name in ('errors', 'run_usage', 'run_observation')}
+    source += 'OBSERVATION_MODULES = ' + repr(modules) + '\n'
+    source += f'OBSERVATION_LIMITS = {MAX_TRANSCRIPT_BYTES, MAX_TRANSCRIPT_SCAN_SECONDS!r}\n'
     source += (directory / 'remote_worker.py').read_text()
     return json.dumps(source).encode() + b'\n'
 
@@ -167,27 +173,57 @@ def run_remote(session, target, version, cwd=None, env_override=None, initial_pr
     paths = _headless_artifact_paths(session, run_id, attempt)
     paths['remote'] = target
     start = datetime.now(timezone.utc)
-    child = None
+    child = receiver = out = err = None
     cancelled = timed_out = budget_exceeded = credential_expired = False
     handlers = _route_termination_to_interrupt()
+    observation_ready = threading.Event()
+    observation_lock = threading.Lock()
+
+    def receive(source, output):
+        for line in source:
+            try:
+                frame = json.loads(line)
+                if frame.get('stream') == 'stdout':
+                    with observation_lock:
+                        observation_ready.clear()
+                        output.write(frame['data'])
+                        output.flush()
+                elif frame.get('stream') == 'observation':
+                    evidence = frame['evidence']
+                    evidence.update(stdout_path=paths['stdout_path'], run_id=paths['run_id'], attempt_id=paths.get('attempt_id'))
+                    with observation_lock:
+                        paths['usage_evidence'] = evidence
+                        observation_ready.set()
+            except (ValueError, TypeError, KeyError, AttributeError):
+                continue
+
     try:
-        with open(paths['stdout_path'], 'w') as out, open(paths['stderr_path'], 'w') as err:
-            child = subprocess.Popen(ssh_command(target, 'run', remote_prefix), env={**os.environ, **(env_override or {})},
-                                     stdin=subprocess.PIPE, stdout=out, stderr=err)
-            child.stdin.write(worker_input() + json.dumps(payload).encode() + b'\n')
-            child.stdin.flush()
-            deadline = time.monotonic() + timeout_seconds if timeout_seconds else None
-            while child.poll() is None:
-                if time.time() >= payload['expires_at']:
-                    credential_expired = True
-                    break
-                if budget_check and budget_check(paths):
-                    budget_exceeded = True
-                    break
-                if deadline and time.monotonic() >= deadline:
-                    timed_out = True
-                    break
-                time.sleep(0.1)
+        out = open(paths['stdout_path'], 'w', encoding='utf-8')
+        err = open(paths['stderr_path'], 'w', encoding='utf-8')
+        child = subprocess.Popen(ssh_command(target, 'run', remote_prefix), env={**os.environ, **(env_override or {})},
+                                 stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=err)
+        receiver = threading.Thread(target=receive, args=(child.stdout, out))
+        receiver.start()
+        child.stdin.write(worker_input() + json.dumps(payload).encode() + b'\n')
+        child.stdin.flush()
+        deadline = time.monotonic() + timeout_seconds if timeout_seconds else None
+        while child.poll() is None:
+            if time.time() >= payload['expires_at']:
+                credential_expired = True
+                break
+            with observation_lock:
+                if budget_check and observation_ready.is_set():
+                    observation_ready.clear()
+                    exceeded = budget_check(paths)
+                else:
+                    exceeded = False
+            if exceeded:
+                budget_exceeded = True
+                break
+            if deadline and time.monotonic() >= deadline:
+                timed_out = True
+                break
+            time.sleep(0.1)
     except KeyboardInterrupt:
         cancelled = True
     except (OSError, ValueError) as error:
@@ -208,6 +244,12 @@ def run_remote(session, target, version, cwd=None, env_override=None, initial_pr
                 except subprocess.TimeoutExpired:
                     child.kill()
                     child.wait()
+        if receiver:
+            receiver.join()
+        if out:
+            out.close()
+        if err:
+            err.close()
         _restore_signal_handlers(handlers)
         _combine_headless_transcript(paths)
     info = {**_headless_run_info(paths, spec, start, child.returncode), 'remote': target,

package/src/remote_worker.py

@@ -12,9 +12,26 @@ import sys
 import tempfile
 import threading
 import time
+import types
+from datetime import datetime, timezone
 
 # Supplied by the controller before this module is executed.
 SANDBOX_SOURCE = globals().get('SANDBOX_SOURCE', '')
+OBSERVATION_MODULES = globals().get('OBSERVATION_MODULES', {})
+OBSERVATION_LIMITS = globals().get('OBSERVATION_LIMITS', (128 * 1024 * 1024, 1))
+
+
+def observation_runtime():
+    # Load only controller-owned readers, with no worker installation required.
+    package = types.ModuleType('cdx_observation')
+    package.__path__ = []
+    sys.modules[package.__name__] = package
+    for name, source in OBSERVATION_MODULES.items():
+        module = types.ModuleType(package.__name__ + '.' + name)
+        module.__package__ = package.__name__
+        sys.modules[module.__name__] = module
+        exec(compile(source, name + '.py', 'exec'), module.__dict__)
+    return sys.modules[package.__name__ + '.run_usage'], sys.modules[package.__name__ + '.run_observation']
 
 
 def version():
@@ -144,6 +161,7 @@ def main():
                 ['codex', *args], pathlib.Path(payload['cwd']), network=payload['network'],
                 writable=payload['writable'], source=env, auth_home=str(home), provider='codex',
                 observation_home=str(home / 'sessions'))
+        started_at = datetime.now(timezone.utc).isoformat()
         child = subprocess.Popen(command, cwd=payload['cwd'], env=env,
                                  stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                  start_new_session=True)
@@ -153,36 +171,36 @@ def main():
         secrets = [value for value in auth['tokens'].values() if isinstance(value, str) and value]
 
         output_lock = threading.Lock()
-        observed = {}
+        usage_reader, observation_reader = observation_runtime()
+        stdout_path = home / 'stdout.jsonl'
+        stdout_path.touch(mode=0o600)
 
         def snapshot():
-            # Only the fresh per-run home supplies model evidence. No transcript
-            # or authentication content leaves the worker.
+            # Read the same exact-thread evidence as the local supervisor before
+            # volatile storage is removed. Only normalized metadata is exported.
             with output_lock:
-                identifier = observed.get('thread_id')
-                usage = observed.get('usage')
-                if not identifier or not usage:
-                    return
-                for path in (home / 'sessions').rglob('*.jsonl'):
-                    if path.is_symlink() or path.stat().st_size > 16 * 1024 * 1024:
-                        continue
-                    try:
-                        records = [json.loads(line) for line in path.read_text().splitlines()]
-                    except (OSError, ValueError):
-                        continue
-                    if not any(row.get('type') == 'session_meta' and row.get('payload', {}).get('id') == identifier for row in records):
-                        continue
-                    contexts = [row.get('payload', {}) for row in records if row.get('type') == 'turn_context']
-                    models = {row.get('model') for row in contexts}
-                    counts = [row.get('payload', {}).get('info', {}).get('total_token_usage') for row in records
-                              if row.get('type') == 'event_msg' and row.get('payload', {}).get('type') == 'token_count']
-                    if (len(models) == 1 and None not in models and counts and counts[-1]
-                            and all(counts[-1].get(key) == usage.get(key) for key in ('input_tokens', 'output_tokens', 'cached_input_tokens'))):
-                        event = json.dumps({'type': 'cdx.remote.usage', 'usage': usage, 'model': next(iter(models))})
-                        for secret in secrets:
-                            event = event.replace(secret, '[REDACTED]')
-                        print(event, flush=True)
-                    return
+                usage = usage_reader.extract_run_usage('codex', stdout_path)
+                identifier = usage_reader.extract_run_conversation_id('codex', stdout_path)
+                evidence = {'source': 'isolated_codex_rollout', 'thread_id': identifier,
+                            'started_at': started_at, 'usage': usage, 'models': [], 'turns': []}
+                if identifier:
+                    paths = []
+                    deadline = time.monotonic() + OBSERVATION_LIMITS[1]
+                    for directory, subdirs, names in os.walk(home / 'sessions'):
+                        if time.monotonic() > deadline:
+                            paths = []
+                            break
+                        subdirs[:] = [name for name in subdirs if name != 'subagents']
+                        paths.extend(pathlib.Path(directory) / name for name in names
+                                     if name.startswith('rollout-') and name.endswith(f'-{identifier}.jsonl'))
+                        if len(paths) > 1:
+                            break
+                    if len(paths) == 1:
+                        evidence = observation_reader.codex_rollout_evidence(home, paths[0], evidence, OBSERVATION_LIMITS[0])
+                event = json.dumps({'stream': 'observation', 'evidence': evidence})
+                for secret in secrets:
+                    event = event.replace(secret, '[REDACTED]')
+                print(event, flush=True)
 
         def forward(source, target):
             for line in iter(source.readline, b''):
@@ -190,16 +208,13 @@ def main():
                     line = line.replace(secret.encode(), b'[REDACTED]')
                 with output_lock:
                     if target is sys.stdout:
-                        try:
-                            event = json.loads(line)
-                            if event.get('type') == 'thread.started':
-                                observed['thread_id'] = event.get('thread_id')
-                            if event.get('type') == 'turn.completed':
-                                observed['usage'] = event.get('usage')
-                        except (ValueError, AttributeError):
-                            pass
-                    target.buffer.write(line)
-                    target.buffer.flush()
+                        with stdout_path.open('ab') as capture:
+                            capture.write(line)
+                        # Frame provider output so it cannot forge supervisor evidence.
+                        print(json.dumps({'stream': 'stdout', 'data': line.decode('utf-8', errors='replace')}), flush=True)
+                    else:
+                        target.buffer.write(line)
+                        target.buffer.flush()
 
         threads = [threading.Thread(target=forward, args=pair) for pair in
                    ((child.stdout, sys.stdout), (child.stderr, sys.stderr))]

package/src/run_observation.py

@@ -6,8 +6,6 @@ import stat
 from datetime import datetime, timezone
 from pathlib import Path
 
-from .history_models import _exact_transcript
-from .interactive_usage import MAX_TRANSCRIPT_BYTES
 from .run_usage import _usage_from_dict, extract_run_conversation_id, extract_run_usage
 
 
@@ -31,6 +29,9 @@ def codex_attempt_evidence(auth_home, stdout_path, started_at):
     Do not import claimed costs, requested models, messages, or arbitrary files
     from the workspace. The exported object is never writable by the sandbox.
     """
+    from .history_models import _exact_transcript
+    from .interactive_usage import MAX_TRANSCRIPT_BYTES
+
     usage = extract_run_usage("codex", stdout_path)
     identifier = extract_run_conversation_id("codex", stdout_path)
     evidence = {"source": "isolated_codex_rollout", "stdout_path": str(stdout_path),
@@ -41,6 +42,14 @@ def codex_attempt_evidence(auth_home, stdout_path, started_at):
     path, error = _exact_transcript("codex", auth_home, identifier)
     if error or not path:
         return evidence
+    return codex_rollout_evidence(auth_home, path, evidence, MAX_TRANSCRIPT_BYTES)
+
+
+def codex_rollout_evidence(auth_home, path, evidence, max_bytes):
+    """Validate exact-attempt rollout evidence identically on local and remote hosts."""
+    usage = evidence["usage"]
+    identifier = evidence["thread_id"]
+    started_at = evidence["started_at"]
     models = set()
     turns = []
     identity = False
@@ -52,8 +61,8 @@ def codex_attempt_evidence(auth_home, stdout_path, started_at):
         with os.fdopen(descriptor, encoding="utf-8") as handle:
             if not stat.S_ISREG(os.fstat(handle.fileno()).st_mode):
                 return evidence
-            text = handle.read(MAX_TRANSCRIPT_BYTES + 1)
-        if len(text) > MAX_TRANSCRIPT_BYTES:
+            text = handle.read(max_bytes + 1)
+        if len(text) > max_bytes:
             return evidence
         for line in text.splitlines():
             record = json.loads(line)