acmerfight · September 10, 2026 08:51 · Dentonshaw · Sep 10, 2026
diff --git a/00-READ-ME.md b/00-READ-ME.md
diff --git a/analyze.py b/analyze.py
 #!/usr/bin/env python3
 """Validate all predeclared runs and produce the concise Chinese result report."""
 import hashlib
 import json
 import pathlib
 import statistics

 root=pathlib.Path(__file__).resolve().parent
 d=json.loads((root/'results.json').read_text())
 assert d['pilot'] is False and len(d['runs'])==17
 assert len(d['comparisons'])==7
 assert all(r['passed'] for r in d['runs']+d['comparisons'])
 assert all(q['effort']=='low' and q['model']=='gpt-6-astra'
           for r in d['runs'] if r['family']!='steer' for q in r['requests'])
 assert all(r['all_requests_effort']=='low' and r['model']=='gpt-6-astra'
           for r in d['runs'] if r['family']=='steer')

 def group(family,interval,duration=2750):
    return [r for r in d['runs'] if r['family']==family and
            r.get('interval_ms')==interval and r.get('duration_ms')==duration]
 def span(xs):
    low,high=min(xs),max(xs)
    return str(low) if low==high else f'{low}–{high}'
 def count(rs):return span([r['parent_requests'] for r in rs])
 def lat(rs):return span([r['event_to_parent_request_ms'] for r in rs])
 a,b=group('input_event',500),group('input_event',10000)
 c,e=group('wrapper',500),group('wrapper',10000)
 sa,sb=group('input_event',30000,65000),group('input_event',600000,65000)
 steer=[r for r in d['runs'] if r['family']=='steer']
 initial_sizes=sorted({r['requests'][0]['input_bytes'] for r in a+b})

 report=f'''# Codex 等待：受控实验结果

 **结论：在真实 Codex 运行时、本地脚本模型的对照中，缩短等待间隔会造成额外模型请求；外层执行工具的短 yield 也能独立产生同类开销。长等待仍可被用户输入提前结束。**

 执行环境：macOS；{d['version']}；全部模型请求配置为 gpt-6-astra / low，但由 localhost 模拟服务响应。**本次测试没有新增真实模型推理调用；当前聊天的分析和工具调度本身仍会用 token。**

 ## 先看一个真实时间尺度的例子

 让 Codex 等待，第 65 秒固定发来同一条输入。两组唯一主动改变的因素是等待超时：

 | 条件 | 等待上限 | 全部父请求 | 空超时 | 输入发出后多久出现下一请求 |
 |---|---:|---:|---:|---:|
 | 短等待 | 30 秒 | {count(sa)} | {sa[0]['empty_timeouts']} | {lat(sa)} ms |
 | 长等待 | 10 分钟 | {count(sb)} | {sb[0]['empty_timeouts']} | {lat(sb)} ms |

 两组输入都在约第 65 秒发出；长等待没有硬等到第 10 分钟。短组第 30、60 秒的空超时分别多触发一次请求。这里的“减少请求”不能直接换算成“节省相同比例的 token、钱或额度”。请求数包含最初发起等待的请求和最后接收事件的请求。

 ## 全部正式对照

 | 实验 | 重复数 | 短等待父请求 | 长等待父请求 | 判据 |
 |---|---:|---:|---:|---|
 | 固定 2.75 秒注入输入；0.5 秒 vs 10 秒等待 | 3 对 | {count(a)} | {count(b)} | 全部通过 |
 | 固定 2.75 秒异步任务；外层 yield 0.5 秒 vs 10 秒 | 3 对 | {count(c)} | {count(e)} | 全部通过 |
 | 固定 65 秒注入输入；30 秒 vs 10 分钟等待 | 1 对 | {count(sa)} | {count(sb)} | 通过 |
 | 25 分钟等待中，约 0.2 秒后输入 | 3 次 | — | 每次 2 请求 | 全部通过 |

 共 17 次正式运行、7 个成对检查；短尺度按 AB / BA / AB 交替。没有靠反复重跑直到通过来筛选正式结果。

 短尺度输入延迟：短等待 {lat(a)} ms；长等待 {lat(b)} ms。三次 25 分钟等待的输入延迟为 {span([r['steer_to_next_request_ms'] for r in steer])} ms。均满足预先设定的 1000ms 判据。**我们证明的是此次运行及时唤醒，并不宣称两种等待的延迟完全相等或给出生产环境延迟保证。**

 ## 为什么这能说明问题，又不能说明所有问题

 - 运行等待、超时、工具续接的是安装的 Codex 二进制；请求次数由本地 HTTP 服务实际计数，不是拿公式算出来的。
 - 模拟服务把策略固定为“事件没来就继续等，来了就结束”，因此能隔离等待间隔的因果作用；它没有测量真实模型是否会选择这套策略。
 - 外层实验实际执行相同的 JavaScript 定时异步任务；短 yield 多次返回运行状态，长 yield 一次等到结果。**没有声称这一版本允许 wait_agent 嵌入 exec，也没有把这两层等同。**
 - 原始输入字节数仅作诊断。短尺度首请求长度实际出现 {initial_sizes} 字节：运行时生成的上下文并非逐字节相同。模拟策略不读取这些变化，故不影响本实验的请求数因果比较；但不据此作精确输入量／费用比较。
 - 无真实 token／缓存测量，模拟 usage 不代表消耗。未用账号额度条做小样本费用推断，未做跨模型成本外推。

 ## 未完成的部分与调试记录

 最初计划让真实子助手在固定时刻完成，但 pilot 1–6 中虽得到 spawn 成功返回，未观察到子助手模型请求，无法形成有效完成对照。尝试请求分类检查、诊断日志和非 ephemeral 模式后仍未解决，原因尚未定位。正式运行前已在 PROTOCOL.md 中保留原方案并记录修订，改用实际 app-server 用户输入事件。后来 input_event 与 wrapper 调试通过，才启动正式运行。

 **因此，子助手“完成、失败、请求批准”三种通知的端到端可靠性，这次没有新增验证。** 此前的源码函数测试支持邮箱事件会提前结束等待，但不能用它代替完整客户端链路测试。此前测试与本次正式数据不混算。

 ## 必须的结论和后续优先级

 现在可以确定：在无新信息时反复超时，会产生可避免的模型请求；仅关注 wait_agent 的参数可能漏掉通用执行工具的外层 yield。用户输入唤醒不需要以每 30 秒调用模型作为前提。

 这足以支持“减少安静等待期间的无效模型重入”这一优化方向，尚不足以支持“额度节省 X%”或“这是 Astra 耗费额度的主要原因”。

 下一步若要真正提交运行时修复，优先打通子助手通知的完整集成测试，覆盖完成、失败、需要批准、用户输入、通知恰好发生在超时边界。若目标是解释真实账号额度，再做有独立费用计量的 Astra low 配对测试；本轮按停止规则没有为此消耗真实模型额度。

 ## 复现

 需要 Python 3.10+ 与 Codex CLI；仅在上述 macOS 版本验证。脚本默认使用 localhost 模型服务；不需要 API key。app-server 会读取部分本机配置，所以不把整个进程称作完全离线或完全隔离。

 ```bash
 python3 controlled.py --codex /absolute/path/to/codex --output results.json
 python3 analyze.py
 ```

 `controlled.py` 与 `reproduce.py` 必须放在同一目录。完整运行包含两个 65 秒等待。脚本会持续写入结果；失败即停止。所有原始数字见 results.json；分析脚本先校验 17 次运行与 7 个对照，再生成本文。

 第一轮源码分析与本轮补充均记录在[同一个公开 Gist](https://gist.github.com/acmerfight/ddfad0c835d2fefb3f26b7bd3f2b09ee)。从 Gist 首页开始可看到通俗讲解、下载步骤和所有实验文件。
 '''
 (root/'RESULTS.md').write_text(report)
 manifest={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in root.iterdir()
          if p.is_file() and p.name not in ['SHA256.json']}
 (root/'SHA256.json').write_text(json.dumps(manifest,indent=2)+'\n')
 print(json.dumps({'runs':17,'paired_checks':7,'all_passed':True,
                  'real_scale_requests':[sa[0]['parent_requests'],sb[0]['parent_requests']],
                  'real_scale_latency_ms':[sa[0]['event_to_parent_request_ms'],sb[0]['event_to_parent_request_ms']]}))
diff --git a/controlled.py b/controlled.py
 #!/usr/bin/env python3
 """Paired deterministic tests of an installed Codex runtime; zero upstream inference.

 Python 3.10+. Place reproduce.py (from the linked original Gist) beside this file.
 Run: python3 controlled.py --codex /path/to/codex --output results.json
 Use --pilot for one short case per family. --skip-scale omits the 130s scale check.
 """
 import argparse
 import hashlib
 import json
 import pathlib
 import queue
 import re
 import subprocess
 import tempfile
 import threading
 import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

 import reproduce as base


 def fixed_input(command, cwd, duration):
    """Use actual app-server input, timestamped from actual wait item/started."""
    inbox, errors = queue.Queue(), []
    proc = subprocess.Popen(command, cwd=cwd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE, text=True, bufsize=1)
    def reader():
        for line in proc.stdout:
            try: inbox.put(json.loads(line))
            except json.JSONDecodeError: pass
    threading.Thread(target=reader,daemon=True).start()
    threading.Thread(target=lambda:errors.extend(proc.stderr.readlines()),daemon=True).start()
    def send(i,method,params):
        payload={'method':method,'params':params}
        if i is not None:payload['id']=i
        proc.stdin.write(json.dumps(payload)+'\n');proc.stdin.flush()
    def receive(predicate):
        deferred=[];deadline=time.monotonic()+duration/1000+20
        try:
            while time.monotonic()<deadline:
                event=inbox.get(timeout=max(.01,deadline-time.monotonic()))
                base.require('error' not in event,str(event.get('error')))
                if predicate(event):return event
                deferred.append(event)
            raise TimeoutError('No matching app-server event')
        finally:
            for event in deferred:inbox.put(event)
    try:
        send(1,'initialize',{'clientInfo':{'name':'controlled_wait','version':'1.0'},
                            'capabilities':{'experimentalApi':True}})
        receive(lambda e:e.get('id')==1);send(None,'initialized',{})
        send(2,'thread/start',{'model':base.MODEL,'modelProvider':'wait_probe','cwd':cwd,
                              'approvalPolicy':'never','sandbox':'read-only','ephemeral':True})
        tid=receive(lambda e:e.get('id')==2)['result']['thread']['id']
        send(3,'turn/start',{'threadId':tid,'effort':'low',
                            'input':[{'type':'text','text':'Wait for the fixed external event.'}]})
        turn=receive(lambda e:e.get('id')==3)['result']['turn']['id']
        receive(lambda e:e.get('method')=='item/started' and
                e.get('params',{}).get('item',{}).get('type')=='collabAgentToolCall')
        start=time.monotonic()
        time.sleep(duration/1000)
        sent=time.monotonic()
        send(4,'turn/steer',{'threadId':tid,'expectedTurnId':turn,
                             'input':[{'type':'text','text':'WAKE_FIXED_EVENT'}]})
        receive(lambda e:e.get('method')=='turn/completed')
    finally:
        proc.stdin.close()
        try:proc.wait(timeout=10)
        except subprocess.TimeoutExpired:proc.terminate();proc.wait(timeout=10)
    base.require(proc.returncode==0,''.join(errors)[-1000:])
    return start,sent


 def run_case(binary, family, interval, duration=2750, minimum=1):
    requests, errors = [], []
    started = threading.Event()
    state = {'parent_key': None, 'event_at': None, 'start_at': None,
             'parent_count': 0, 'child_count': 0, 'cell': None}

    def message(text):
        return {'type': 'message', 'role': 'assistant', 'id': 'msg',
                'content': [{'type': 'output_text', 'text': text}]}

    def function(name, args, namespace='collaboration'):
        return {'type': 'function_call', 'call_id': f'call-{len(requests)}',
                'name': name, 'namespace': namespace, 'arguments': json.dumps(args)}

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, *_):
            pass

        def do_POST(self):
            try:
                body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))
                key = body.get('prompt_cache_key')
                base.require(key is not None, 'Missing routing key')
                if state['parent_key'] is None:
                    state['parent_key'] = key
                inputs = body.get('input', [])
                # Forks may inherit a cache routing key; classify by the fixed user task.
                child = any(i.get('role') == 'user' and
                            'Fixed-duration local test worker. Return the fixture result.' in
                            json.dumps(i.get('content', [])) for i in inputs)
                role = 'child' if child else 'parent'
                rendered = json.dumps(inputs, ensure_ascii=False)
                outputs = [i.get('output') for i in inputs if i.get('type') in
                           ['function_call_output', 'custom_tool_call_output']]
                # Retain only fixture output strings and numerical input measurements.
                request = {'at': time.monotonic(), 'role': role,
                           'input_bytes': len(rendered.encode()), 'input_items': len(inputs),
                           'model': body.get('model'), 'effort': body.get('reasoning', {}).get('effort'),
                           'outputs': outputs,
                           'completion_visible': 'CHILD_FINISHED_FIXED' in rendered,
                           'input_event_visible': 'WAKE_FIXED_EVENT' in rendered}
                requests.append(request)
                print(f'  local request {len(requests)} role={role}', flush=True)
                if not child and family == 'completion' and state['parent_count'] == 1:
                    print('  spawn result: ' + json.dumps(outputs[-1:]), flush=True)
                    base.require(outputs and 'fixed_worker' in json.dumps(outputs[-1]),
                                 'Spawn failed: ' + json.dumps(outputs[-1:] ))
                base.require(len(requests) < 100, 'Request budget exhausted')
                base.require(request['effort'] == 'low', 'Non-low request')
                base.require(request['model'] == 'gpt-6-astra', 'Unexpected model')
                if child:
                    state['child_count'] += 1
                    base.require(state['child_count'] == 1, 'Unexpected child loop')
                    base.require(started.wait(15), 'Parent never started waiting')
                    deadline = state['start_at'] + duration / 1000
                    time.sleep(max(0, deadline - time.monotonic()))
                    state['event_at'] = time.monotonic()
                    item = message('CHILD_FINISHED_FIXED')
                else:
                    n = state['parent_count']
                    state['parent_count'] += 1
                    if family == 'input_event':
                        item = (message('PARENT_DONE') if request['input_event_visible'] else
                                function('wait_agent', {'timeout_ms':interval}))
                    elif family == 'completion':
                        if n == 0:
                            item = function('spawn_agent', {'task_name': 'fixed_worker',
                                'message': 'Fixed-duration local test worker. Return the fixture result.',
                                'fork_turns': 'none'})
                        elif request['completion_visible']:
                            item = message('PARENT_DONE')
                        else:
                            item = function('wait_agent', {'timeout_ms': interval})
                            if not started.is_set():
                                state['start_at'] = time.monotonic()
                                started.set()
                    else:
                        if n == 0:
                            code = ('// @exec: ' + json.dumps({'yield_time_ms': interval}) + '\n'
                                    f'await new Promise(resolve => setTimeout(resolve, {duration}));\n'
                                    'text("WRAPPER_DONE_FIXED");')
                            item = {'type': 'custom_tool_call', 'call_id': 'exec-first',
                                    'name': 'exec', 'namespace': 'functions', 'input': code}
                            state['start_at'] = time.monotonic()
                        else:
                            last = json.dumps(outputs[-1]) if outputs else ''
                            match = re.search(r'Script running with cell ID ([^\s"\\]+)', last)
                            if match:
                                state['cell'] = match.group(1)
                                item = function('wait', {'cell_id': state['cell'],
                                    'yield_time_ms': interval, 'max_tokens': 1000}, 'functions')
                            elif 'WRAPPER_DONE_FIXED' in last:
                                item = message('PARENT_DONE')
                            else:
                                raise AssertionError('Unexpected wrapper result: ' + last[:1500])
                identifier = f'fixture-{len(requests)}'
                events = [{'type': 'response.created', 'response': {'id': identifier}},
                          {'type': 'response.output_item.done', 'item': item},
                          {'type': 'response.completed', 'response': {'id': identifier,
                            'usage': {'input_tokens': 0, 'output_tokens': 0, 'total_tokens': 0}}}]
                data = ''.join('data: ' + json.dumps(e) + '\n\n' for e in events).encode()
                self.send_response(200)
                self.send_header('Content-Type', 'text/event-stream')
                self.send_header('Content-Length', str(len(data)))
                self.end_headers()
                self.wfile.write(data)
            except Exception as exc:
                errors.append(str(exc))
                print('  fixture error: ' + str(exc), flush=True)
                self.send_error(500, 'Local fixture failure')

    server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
    server.daemon_threads = True
    threading.Thread(target=server.serve_forever, daemon=True).start()
    try:
        with tempfile.TemporaryDirectory(prefix='controlled-wait-') as folder:
            settings = base.configuration(server.server_port, minimum, 30000, 3600000)
            settings['features.code_mode'] = family == 'wrapper'
            if family == 'input_event':
                command=base.with_config([binary,'app-server'],settings)
                state['start_at'],state['event_at']=fixed_input(command,folder,duration)
                proc=None
            else:
                command = [binary, 'exec', '--ignore-user-config', '--ephemeral',
                       '--skip-git-repo-check', '--json', '-s', 'read-only',
                       '-m', base.MODEL, '-C', folder]
                base.with_config(command, settings)
                command += ['Controlled local fixture. Run one fixed-duration worker and wait for its result.']
            try:
                if family != 'input_event':
                    proc = subprocess.run(command, stdin=subprocess.DEVNULL, capture_output=True,
                                      text=True, timeout=duration/1000 + 15)
            except subprocess.TimeoutExpired as exc:
                print('  runtime stdout: ' + str(exc.stdout)[-6000:], flush=True)
                print('  runtime stderr: ' + str(exc.stderr)[-2000:], flush=True)
                raise
            base.require(not errors, '; '.join(errors))
            if proc is not None:
                base.require(proc.returncode == 0, proc.stderr[-2000:])
                base.require('PARENT_DONE' in proc.stdout, 'Parent failed to finish')
    finally:
        server.shutdown()
        server.server_close()
    parent = [r for r in requests if r['role'] == 'parent']
    event_latency = None
    if family in ['completion','input_event']:
        if family == 'completion':
            base.require(state['child_count'] == 1, 'Expected exactly one actual child')
            base.require(parent[-1]['completion_visible'], 'Completion missing from parent input')
        else:
            base.require(parent[-1]['input_event_visible'], 'Fixed input missing')
        event_latency = (parent[-1]['at'] - state['event_at']) * 1000
        base.require(0 <= event_latency < 1000, f'Completion latency exceeded bound: {event_latency}')
    # Count outputs from the last logical request once, not repeated transcript copies.
    last_outputs = parent[-1]['outputs']
    timeouts = sum('"timed_out":true' in json.dumps(o).replace(' ', '').replace('\\"', '"')
                   for o in last_outputs)
    origin = requests[0]['at']
    for r in requests:
        r['at_ms'] = round((r.pop('at') - origin)*1000, 2)
        r.pop('outputs')
    return {'family': family, 'interval_ms': interval, 'duration_ms': duration,
            'minimum_ms': minimum, 'passed': True, 'parent_requests': len(parent),
            'child_requests': state['child_count'], 'empty_timeouts': timeouts,
            'event_to_parent_request_ms': round(event_latency, 2) if event_latency is not None else None,
            'observed_event_delay_ms': round((state['event_at']-state['start_at'])*1000,2)
                if state['event_at'] is not None else None,
            'parent_input_bytes_sum': sum(r['input_bytes'] for r in parent),
            'last_parent_input_items': parent[-1]['input_items'],
            'requests': requests}


 def main():
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument('--codex', required=True)
    p.add_argument('--output', type=pathlib.Path, default=pathlib.Path('results.json'))
    p.add_argument('--pilot', action='store_true')
    p.add_argument('--skip-scale', action='store_true')
    args = p.parse_args()
    result = {'pilot': args.pilot, 'upstream_model_requests': 0,
              'version': subprocess.check_output([args.codex, '--version'], text=True).strip(),
              'binary_sha256': hashlib.sha256(pathlib.Path(args.codex).read_bytes()).hexdigest(),
              'runs': [], 'comparisons': []}

    def save():
        args.output.write_text(json.dumps(result, indent=2, ensure_ascii=False)+'\n')

    def one(family, interval, duration=2750, minimum=1):
        print(f'RUN {family} interval={interval} duration={duration}', flush=True)
        try:
            r = run_case(args.codex, family, interval, duration, minimum)
        except Exception as exc:
            r = {'family': family, 'interval_ms': interval, 'duration_ms': duration,
                 'passed': False, 'error': str(exc)}
            result['runs'].append(r)
            save()
            raise
        result['runs'].append(r)
        save()
        print(json.dumps({k:v for k,v in r.items() if k != 'requests'}), flush=True)
        return r

    if args.pilot:
        for family in ['input_event', 'wrapper']:
            one(family, 500)
        return
    for family in ['input_event', 'wrapper']:
        for pair, order in enumerate([(500,10000), (10000,500), (500,10000)], 1):
            pair_runs = {interval:one(family,interval) for interval in order}
            a,b = pair_runs[500],pair_runs[10000]
            base.require(a['parent_requests'] > b['parent_requests'], 'No request reduction')
            if family == 'input_event':
                base.require(a['empty_timeouts'] >= 2 and b['empty_timeouts'] == 0,
                             'Timeout prediction failed')
            result['comparisons'].append({'family':family,'pair':pair,'passed':True,
                'short_requests':a['parent_requests'],'long_requests':b['parent_requests']})
            save()
    if not args.skip_scale:
        a=one('input_event',30000,65000,10000)
        b=one('input_event',600000,65000,10000)
        base.require(a['empty_timeouts'] >= 2 and b['empty_timeouts'] == 0 and
                     a['parent_requests'] > b['parent_requests'], 'Scale prediction failed')
        result['comparisons'].append({'family':'real_scale','passed':True,
            'short_requests':a['parent_requests'],'long_requests':b['parent_requests']})
        save()
    for _ in range(3):
        print('RUN steer_25min', flush=True)
        r=base.mock_case(args.codex, ('steer_25min',[{'timeout_ms':1500000}],1,30000,3600000))
        base.require(r['steer_to_next_request_ms'] < 1000, 'Steer latency exceeded bound')
        # Synthetic usage from this legacy probe is not a measured model cost.
        r.pop('synthetic_usage')
        r['family']='steer'
        result['runs'].append(r)
        save()
        print(json.dumps(r), flush=True)


 if __name__ == '__main__':
    main()
diff --git a/LICENSE.txt b/LICENSE.txt
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

 TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

 1.  Definitions.

    "License" shall mean the terms and conditions for use, reproduction,
    and distribution as defined by Sections 1 through 9 of this document.

    "Licensor" shall mean the copyright owner or entity authorized by
    the copyright owner that is granting the License.

    "Legal Entity" shall mean the union of the acting entity and all
    other entities that control, are controlled by, or are under common
    control with that entity. For the purposes of this definition,
    "control" means (i) the power, direct or indirect, to cause the
    direction or management of such entity, whether by contract or
    otherwise, or (ii) ownership of fifty percent (50%) or more of the
    outstanding shares, or (iii) beneficial ownership of such entity.

    "You" (or "Your") shall mean an individual or Legal Entity
    exercising permissions granted by this License.

    "Source" form shall mean the preferred form for making modifications,
    including but not limited to software source code, documentation
    source, and configuration files.

    "Object" form shall mean any form resulting from mechanical
    transformation or translation of a Source form, including but
    not limited to compiled object code, generated documentation,
    and conversions to other media types.

    "Work" shall mean the work of authorship, whether in Source or
    Object form, made available under the License, as indicated by a
    copyright notice that is included in or attached to the work
    (an example is provided in the Appendix below).

    "Derivative Works" shall mean any work, whether in Source or Object
    form, that is based on (or derived from) the Work and for which the
    editorial revisions, annotations, elaborations, or other modifications
    represent, as a whole, an original work of authorship. For the purposes
    of this License, Derivative Works shall not include works that remain
    separable from, or merely link (or bind by name) to the interfaces of,
    the Work and Derivative Works thereof.

    "Contribution" shall mean any work of authorship, including
    the original version of the Work and any modifications or additions
    to that Work or Derivative Works thereof, that is intentionally
    submitted to Licensor for inclusion in the Work by the copyright owner
    or by an individual or Legal Entity authorized to submit on behalf of
    the copyright owner. For the purposes of this definition, "submitted"
    means any form of electronic, verbal, or written communication sent
    to the Licensor or its representatives, including but not limited to
    communication on electronic mailing lists, source code control systems,
    and issue tracking systems that are managed by, or on behalf of, the
    Licensor for the purpose of discussing and improving the Work, but
    excluding communication that is conspicuously marked or otherwise
    designated in writing by the copyright owner as "Not a Contribution."

    "Contributor" shall mean Licensor and any individual or Legal Entity
    on behalf of whom a Contribution has been received by Licensor and
    subsequently incorporated within the Work.

 2.  Grant of Copyright License. Subject to the terms and conditions of
    this License, each Contributor hereby grants to You a perpetual,
    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
    copyright license to reproduce, prepare Derivative Works of,
    publicly display, publicly perform, sublicense, and distribute the
    Work and such Derivative Works in Source or Object form.

 3.  Grant of Patent License. Subject to the terms and conditions of
    this License, each Contributor hereby grants to You a perpetual,
    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
    (except as stated in this section) patent license to make, have made,
    use, offer to sell, sell, import, and otherwise transfer the Work,
    where such license applies only to those patent claims licensable
    by such Contributor that are necessarily infringed by their
    Contribution(s) alone or by combination of their Contribution(s)
    with the Work to which such Contribution(s) was submitted. If You
    institute patent litigation against any entity (including a
    cross-claim or counterclaim in a lawsuit) alleging that the Work
    or a Contribution incorporated within the Work constitutes direct
    or contributory patent infringement, then any patent licenses
    granted to You under this License for that Work shall terminate
    as of the date such litigation is filed.

 4.  Redistribution. You may reproduce and distribute copies of the
    Work or Derivative Works thereof in any medium, with or without
    modifications, and in Source or Object form, provided that You
    meet the following conditions:

    (a) You must give any other recipients of the Work or
    Derivative Works a copy of this License; and

    (b) You must cause any modified files to carry prominent notices
    stating that You changed the files; and

    (c) You must retain, in the Source form of any Derivative Works
    that You distribute, all copyright, patent, trademark, and
    attribution notices from the Source form of the Work,
    excluding those notices that do not pertain to any part of
    the Derivative Works; and

    (d) If the Work includes a "NOTICE" text file as part of its
    distribution, then any Derivative Works that You distribute must
    include a readable copy of the attribution notices contained
    within such NOTICE file, excluding those notices that do not
    pertain to any part of the Derivative Works, in at least one
    of the following places: within a NOTICE text file distributed
    as part of the Derivative Works; within the Source form or
    documentation, if provided along with the Derivative Works; or,
    within a display generated by the Derivative Works, if and
    wherever such third-party notices normally appear. The contents
    of the NOTICE file are for informational purposes only and
    do not modify the License. You may add Your own attribution
    notices within Derivative Works that You distribute, alongside
    or as an addendum to the NOTICE text from the Work, provided
    that such additional attribution notices cannot be construed
    as modifying the License.

    You may add Your own copyright statement to Your modifications and
    may provide additional or different license terms and conditions
    for use, reproduction, or distribution of Your modifications, or
    for any such Derivative Works as a whole, provided Your use,
    reproduction, and distribution of the Work otherwise complies with
    the conditions stated in this License.

 5.  Submission of Contributions. Unless You explicitly state otherwise,
    any Contribution intentionally submitted for inclusion in the Work
    by You to the Licensor shall be under the terms and conditions of
    this License, without any additional terms or conditions.
    Notwithstanding the above, nothing herein shall supersede or modify
    the terms of any separate license agreement you may have executed
    with Licensor regarding such Contributions.

 6.  Trademarks. This License does not grant permission to use the trade
    names, trademarks, service marks, or product names of the Licensor,
    except as required for reasonable and customary use in describing the
    origin of the Work and reproducing the content of the NOTICE file.

 7.  Disclaimer of Warranty. Unless required by applicable law or
    agreed to in writing, Licensor provides the Work (and each
    Contributor provides its Contributions) on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
    implied, including, without limitation, any warranties or conditions
    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
    PARTICULAR PURPOSE. You are solely responsible for determining the
    appropriateness of using or redistributing the Work and assume any
    risks associated with Your exercise of permissions under this License.

 8.  Limitation of Liability. In no event and under no legal theory,
    whether in tort (including negligence), contract, or otherwise,
    unless required by applicable law (such as deliberate and grossly
    negligent acts) or agreed to in writing, shall any Contributor be
    liable to You for damages, including any direct, indirect, special,
    incidental, or consequential damages of any character arising as a
    result of this License or out of the use or inability to use the
    Work (including but not limited to damages for loss of goodwill,
    work stoppage, computer failure or malfunction, or any and all
    other commercial damages or losses), even if such Contributor
    has been advised of the possibility of such damages.

 9.  Accepting Warranty or Additional Liability. While redistributing
    the Work or Derivative Works thereof, You may choose to offer,
    and charge a fee for, acceptance of support, warranty, indemnity,
    or other liability obligations and/or rights consistent with this
    License. However, in accepting such obligations, You may act only
    on Your own behalf and on Your sole responsibility, not on behalf
    of any other Contributor, and only if You agree to indemnify,
    defend, and hold each Contributor harmless for any liability
    incurred by, or claims asserted against, such Contributor by reason
    of your accepting any such warranty or additional liability.

 END OF TERMS AND CONDITIONS

 APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

 Copyright 2025 OpenAI

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
diff --git a/LIVE-PROTOCOL.md b/LIVE-PROTOCOL.md
diff --git a/live-results.json b/live-results.json
 {
  "runtime": "codex-cli 0.153.4",
  "date": "2026-09-09",
  "mode": "REAL MODEL",
  "usage_scope": "Parent and child requests reported separately; no quota-price conversion.",
  "cases": {
    "wait2": {
      "model": "gpt-6-astra",
      "effort": "low",
      "requests": [
        {
          "input_tokens": 17953,
          "cached_input_tokens": 7936,
          "cache_write_input_tokens": 0,
          "output_tokens": 20,
          "reasoning_output_tokens": 0,
          "total_tokens": 17973,
          "uncached_input_tokens": 10017
        },
        {
          "input_tokens": 17998,
          "cached_input_tokens": 17792,
          "cache_write_input_tokens": 0,
          "output_tokens": 20,
          "reasoning_output_tokens": 0,
          "total_tokens": 18018,
          "uncached_input_tokens": 206
        },
        {
          "input_tokens": 18043,
          "cached_input_tokens": 17792,
          "cache_write_input_tokens": 0,
          "output_tokens": 5,
          "reasoning_output_tokens": 0,
          "total_tokens": 18048,
          "uncached_input_tokens": 251
        }
      ],
      "request_count": 3,
      "total": {
        "input_tokens": 53994,
        "cached_input_tokens": 43520,
        "cache_write_input_tokens": 0,
        "output_tokens": 45,
        "reasoning_output_tokens": 0,
        "total_tokens": 54039,
        "uncached_input_tokens": 10474
      },
      "tools": [
        {
          "name": "wait_agent",
          "args": {
            "timeout_ms": 100
          }
        },
        {
          "name": "wait_agent",
          "args": {
            "timeout_ms": 100
          }
        }
      ],
      "wait_outputs": [
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}",
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}"
      ],
      "fixture_present_in_history": true,
      "rollout_sha256": "ddf2a217cd033f8e9ca2ab15563d0083649979be07176408ecfc7a2432271738"
    },
    "wait0": {
      "model": "gpt-6-astra",
      "effort": "low",
      "requests": [
        {
          "input_tokens": 17769,
          "cached_input_tokens": 7936,
          "cache_write_input_tokens": 0,
          "output_tokens": 5,
          "reasoning_output_tokens": 0,
          "total_tokens": 17774,
          "uncached_input_tokens": 9833
        }
      ],
      "request_count": 1,
      "total": {
        "input_tokens": 17769,
        "cached_input_tokens": 7936,
        "cache_write_input_tokens": 0,
        "output_tokens": 5,
        "reasoning_output_tokens": 0,
        "total_tokens": 17774,
        "uncached_input_tokens": 9833
      },
      "tools": [],
      "wait_outputs": [],
      "fixture_present_in_history": true,
      "rollout_sha256": "a1a3a95077f8e7af794138acc096efff95093a3ce0a6aa1742b2b9f6cd614bcf"
    },
    "fork_na": {
      "model": "gpt-6-astra",
      "effort": "low",
      "requests": [
        {
          "input_tokens": 17863,
          "cached_input_tokens": 7936,
          "cache_write_input_tokens": 0,
          "output_tokens": 152,
          "reasoning_output_tokens": 56,
          "total_tokens": 18015,
          "uncached_input_tokens": 9927
        },
        {
          "input_tokens": 18037,
          "cached_input_tokens": 17664,
          "cache_write_input_tokens": 0,
          "output_tokens": 56,
          "reasoning_output_tokens": 0,
          "total_tokens": 18093,
          "uncached_input_tokens": 373
        },
        {
          "input_tokens": 18115,
          "cached_input_tokens": 17920,
          "cache_write_input_tokens": 0,
          "output_tokens": 21,
          "reasoning_output_tokens": 0,
          "total_tokens": 18136,
          "uncached_input_tokens": 195
        },
        {
          "input_tokens": 18200,
          "cached_input_tokens": 17920,
          "cache_write_input_tokens": 0,
          "output_tokens": 21,
          "reasoning_output_tokens": 0,
          "total_tokens": 18221,
          "uncached_input_tokens": 280
        },
        {
          "input_tokens": 18285,
          "cached_input_tokens": 18048,
          "cache_write_input_tokens": 0,
          "output_tokens": 5,
          "reasoning_output_tokens": 0,
          "total_tokens": 18290,
          "uncached_input_tokens": 237
        }
      ],
      "request_count": 5,
      "total": {
        "input_tokens": 90500,
        "cached_input_tokens": 79488,
        "cache_write_input_tokens": 0,
        "output_tokens": 255,
        "reasoning_output_tokens": 56,
        "total_tokens": 90755,
        "uncached_input_tokens": 11012
      },
      "tools": [
        {
          "name": "spawn_agent",
          "args": {
            "task_name": "probe_first",
            "fork_turns": "none",
            "model": "gpt-6-astra",
            "reasoning_effort": "low"
          }
        },
        {
          "name": "spawn_agent",
          "args": {
            "task_name": "probe_second",
            "fork_turns": "all"
          }
        },
        {
          "name": "wait_agent",
          "args": {
            "timeout_ms": 600000
          }
        },
        {
          "name": "wait_agent",
          "args": {
            "timeout_ms": 600000
          }
        }
      ],
      "wait_outputs": [
        "{\"message\":\"Wait completed.\",\"timed_out\":false}",
        "{\"message\":\"Wait completed.\",\"timed_out\":false}"
      ],
      "fixture_present_in_history": true,
      "rollout_sha256": "afa2ab8e5afdc0be5e189c8a3a04312aaddffcf20532942352d22754170df096",
      "children": {
        "all": {
          "model": "gpt-6-astra",
          "effort": "low",
          "requests": [
            {
              "input_tokens": 18440,
              "cached_input_tokens": 11904,
              "cache_write_input_tokens": 0,
              "output_tokens": 7,
              "reasoning_output_tokens": 0,
              "total_tokens": 18447,
              "uncached_input_tokens": 6536
            }
          ],
          "request_count": 1,
          "total": {
            "input_tokens": 18440,
            "cached_input_tokens": 11904,
            "cache_write_input_tokens": 0,
            "output_tokens": 7,
            "reasoning_output_tokens": 0,
            "total_tokens": 18447,
            "uncached_input_tokens": 6536
          },
          "tools": [],
          "wait_outputs": [],
          "fixture_present_in_history": true,
          "rollout_sha256": "ae34c5df47d9ec8671752718af8f9b55a6eae858bd5a807e3ef725ecaa12a065"
        },
        "none": {
          "model": "gpt-6-astra",
          "effort": "low",
          "requests": [
            {
              "input_tokens": 15317,
              "cached_input_tokens": 6784,
              "cache_write_input_tokens": 0,
              "output_tokens": 7,
              "reasoning_output_tokens": 0,
              "total_tokens": 15324,
              "uncached_input_tokens": 8533
            }
          ],
          "request_count": 1,
          "total": {
            "input_tokens": 15317,
            "cached_input_tokens": 6784,
            "cache_write_input_tokens": 0,
            "output_tokens": 7,
            "reasoning_output_tokens": 0,
            "total_tokens": 15324,
            "uncached_input_tokens": 8533
          },
          "tools": [],
          "wait_outputs": [],
          "fixture_present_in_history": false,
          "rollout_sha256": "b66d9f8b4602ad590f14f4f8e6e47d49dd40061e2f5dd85979e866f59735411d"
        }
      }
    },
    "fork_an": {
      "model": "gpt-6-astra",
      "effort": "low",
      "requests": [
        {
          "input_tokens": 17863,
          "cached_input_tokens": 7936,
          "cache_write_input_tokens": 0,
          "output_tokens": 125,
          "reasoning_output_tokens": 45,
          "total_tokens": 17988,
          "uncached_input_tokens": 9927
        },
        {
          "input_tokens": 18010,
          "cached_input_tokens": 17664,
          "cache_write_input_tokens": 0,
          "output_tokens": 72,
          "reasoning_output_tokens": 0,
          "total_tokens": 18082,
          "uncached_input_tokens": 346
        },
        {
          "input_tokens": 18104,
          "cached_input_tokens": 17792,
          "cache_write_input_tokens": 0,
          "output_tokens": 21,
          "reasoning_output_tokens": 0,
          "total_tokens": 18125,
          "uncached_input_tokens": 312
        },
        {
          "input_tokens": 18189,
          "cached_input_tokens": 17920,
          "cache_write_input_tokens": 0,
          "output_tokens": 21,
          "reasoning_output_tokens": 0,
          "total_tokens": 18210,
          "uncached_input_tokens": 269
        },
        {
          "input_tokens": 18274,
          "cached_input_tokens": 18048,
          "cache_write_input_tokens": 0,
          "output_tokens": 5,
          "reasoning_output_tokens": 0,
          "total_tokens": 18279,
          "uncached_input_tokens": 226
        }
      ],
      "request_count": 5,
      "total": {
        "input_tokens": 90440,
        "cached_input_tokens": 79360,
        "cache_write_input_tokens": 0,
        "output_tokens": 244,
        "reasoning_output_tokens": 45,
        "total_tokens": 90684,
        "uncached_input_tokens": 11080
      },
      "tools": [
        {
          "name": "spawn_agent",
          "args": {
            "task_name": "probe_first",
            "fork_turns": "all"
          }
        },
        {
          "name": "spawn_agent",
          "args": {
            "task_name": "probe_second",
            "fork_turns": "none",
            "model": "gpt-6-astra",
            "reasoning_effort": "low"
          }
        },
        {
          "name": "wait_agent",
          "args": {
            "timeout_ms": 600000
          }
        },
        {
          "name": "wait_agent",
          "args": {
            "timeout_ms": 600000
          }
        }
      ],
      "wait_outputs": [
        "{\"message\":\"Wait completed.\",\"timed_out\":false}",
        "{\"message\":\"Wait completed.\",\"timed_out\":false}"
      ],
      "fixture_present_in_history": true,
      "rollout_sha256": "4c6044f7fede7ae349e24b587c9c6e18456bc6f0db535fe4f691047e47d46404",
      "children": {
        "all": {
          "model": "gpt-6-astra",
          "effort": "low",
          "requests": [
            {
              "input_tokens": 18440,
              "cached_input_tokens": 0,
              "cache_write_input_tokens": 0,
              "output_tokens": 7,
              "reasoning_output_tokens": 0,
              "total_tokens": 18447,
              "uncached_input_tokens": 18440
            }
          ],
          "request_count": 1,
          "total": {
            "input_tokens": 18440,
            "cached_input_tokens": 0,
            "cache_write_input_tokens": 0,
            "output_tokens": 7,
            "reasoning_output_tokens": 0,
            "total_tokens": 18447,
            "uncached_input_tokens": 18440
          },
          "tools": [],
          "wait_outputs": [],
          "fixture_present_in_history": true,
          "rollout_sha256": "aae85e730a6290cb924d4795895c6c58f5bc1e441d909148b194a7356d1333b4"
        },
        "none": {
          "model": "gpt-6-astra",
          "effort": "low",
          "requests": [
            {
              "input_tokens": 15317,
              "cached_input_tokens": 11904,
              "cache_write_input_tokens": 0,
              "output_tokens": 7,
              "reasoning_output_tokens": 0,
              "total_tokens": 15324,
              "uncached_input_tokens": 3413
            }
          ],
          "request_count": 1,
          "total": {
            "input_tokens": 15317,
            "cached_input_tokens": 11904,
            "cache_write_input_tokens": 0,
            "output_tokens": 7,
            "reasoning_output_tokens": 0,
            "total_tokens": 15324,
            "uncached_input_tokens": 3413
          },
          "tools": [],
          "wait_outputs": [],
          "fixture_present_in_history": false,
          "rollout_sha256": "186d7daa41f8db51a4221264e1fc0a4d190fa979b2ec122a80d3ccff4aef0bc4"
        }
      }
    }
  }
 }
diff --git a/LIVE-RESULTS.md b/LIVE-RESULTS.md
diff --git a/LIVE-SHA256.json b/LIVE-SHA256.json
 {
  "LIVE-RESULTS.md": "a76ab8f779772955b2ec3cf8693ca43ab2a2ac5a3a407923c865abd9e0f3a772",
  "LIVE-PROTOCOL.md": "d7975302f61a94f48329c69c5d13198ed000d61b0268feecce97dfc54b983bd0",
  "live_run.py": "5960e3a4dac86c92eccb830486a73c9a4549952f5a84bd65640d6a8819b2d679",
  "live_analyze.py": "1831517eab3cba5ea5000c6c348ea4449c0588ea3e0eb397092912d5754790fe",
  "live-results.json": "8a623a38659ff09423d9d37689bbafc3d9ca9ed17501349ef2f24c96237af5b9"
 }
diff --git a/live_analyze.py b/live_analyze.py
 #!/usr/bin/env python3
 """Extract only this experiment's usage from local Codex sessions."""
 import json,pathlib,hashlib,os
 from live_run import ROOT,RAW,FIXTURE

 OUT=ROOT
 SESSIONS=pathlib.Path(os.environ.get('CODEX_HOME',str(pathlib.Path.home()/'.codex')))/'sessions'
 def read(p):return [json.loads(x) for x in p.read_text().splitlines() if x.strip()]
 def summarize(path,is_child=False):
    rows=read(path)
    starts=[i for i,e in enumerate(rows) if e['type']=='event_msg' and e.get('payload',{}).get('type')=='task_started']
    active=rows[starts[-1]:] if is_child else rows
    contexts=[e['payload'] for e in active if e['type']=='turn_context']
    assert contexts and all(c.get('model')=='gpt-6-astra' and c.get('effort')=='low' for c in contexts)
    usages=[];seen=set();tools=[];wait_outputs=[];last=None
    for e in active:
        v=e.get('payload',{})
        if e['type']=='response_item' and v.get('type')=='function_call':
            args=json.loads(v['arguments']);last=v['name'];tools.append({'name':last,'args':{k:a for k,a in args.items() if k!='message'}})
        if e['type']=='response_item' and v.get('type')=='function_call_output' and last=='wait_agent':
            wait_outputs.append(v.get('output'))
        if e['type']=='event_msg' and v.get('type')=='token_count' and v.get('info'):
            info=v['info'];key=json.dumps(info['total_token_usage'],sort_keys=True)
            if key in seen:continue
            seen.add(key);u=info['last_token_usage'].copy()
            u['uncached_input_tokens']=u['input_tokens']-u['cached_input_tokens']
            usages.append(u)
    completed=[e['payload'] for e in active if e['type']=='event_msg' and e.get('payload',{}).get('type')=='task_complete']
    assert completed
    if is_child:assert len(usages)==1 and not tools and completed[-1]['last_agent_message']=='WORKER_DONE'
    else:assert completed[-1]['last_agent_message']=='DONE'
    return {'model':'gpt-6-astra','effort':'low','requests':usages,'request_count':len(usages),
            'total':{k:sum(u[k] for u in usages) for k in usages[0]},'tools':tools,
            'wait_outputs':wait_outputs,'fixture_present_in_history':FIXTURE in json.dumps(rows,ensure_ascii=False).replace('\\n','\n'),
            'rollout_sha256':hashlib.sha256(path.read_bytes()).hexdigest()}

 def main():
    files=list(SESSIONS.rglob('*.jsonl'));results={};parents={};parent_mtimes=[]
    for name in ['wait2','wait0','fork_na','fork_an']:
        output=RAW/(name+'.stdout.jsonl')
        if not output.exists():continue
        events=read(output)
        if not any(e.get('type')=='turn.completed' for e in events):continue
        tid=next(e['thread_id'] for e in events if e.get('type')=='thread.started')
        p=next(p for p in files if tid in p.name);parents[tid]=name;results[name]=summarize(p);parent_mtimes.append(p.stat().st_mtime)
    for p in files:
        # Only potential children newer than the first parent, to minimize reads.
        if not parents or p.stat().st_mtime<min(parent_mtimes)-600:continue
        try:
            with p.open() as f:meta=json.loads(f.readline()).get('payload',{})
            source=meta.get('source',{})
            if not isinstance(source,dict):continue
            spawn=source.get('subagent',{}).get('thread_spawn',{})
        except (ValueError,AttributeError):continue
        tid=spawn.get('parent_thread_id')
        if tid not in parents:continue
        name=parents[tid];first=spawn['agent_path'].endswith('probe_first')
        mode=('none' if first else 'all') if name=='fork_na' else ('all' if first else 'none')
        results[name].setdefault('children',{})[mode]=summarize(p,True)
    assert set(results)=={'wait2','wait0','fork_na','fork_an'}, 'Run all four cases successfully before analyzing.'
    for name,r in results.items():
        if name.startswith('wait'):
            n=int(name[-1]);assert r['request_count']==n+1 and len(r['tools'])==n
            assert all(t['name']=='wait_agent' and t['args']=={'timeout_ms':100} for t in r['tools'])
        else:
            assert set(r['children'])=={'all','none'}
            assert len([t for t in r['tools'] if t['name']=='spawn_agent'])==2
            assert r['children']['all']['fixture_present_in_history']
            assert not r['children']['none']['fixture_present_in_history']
    result={'runtime':'codex-cli 0.153.4','date':'2026-09-09','mode':'REAL MODEL',
            'usage_scope':'Parent and child requests reported separately; no quota-price conversion.',
            'cases':results}
    (OUT/'live-results-reproduced.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n')
    for n,r in results.items():
        print(n,r['request_count'],r['total'])
        for mode,c in r.get('children',{}).items():print(' child',mode,c['total'],'fixture',c['fixture_present_in_history'])

 if __name__=='__main__':main()
diff --git a/live_run.py b/live_run.py
 #!/usr/bin/env python3
 """Opt-in real Codex/Astra low measurement; uses existing CLI login."""
 import argparse,json,pathlib,subprocess,tempfile,time,os,shutil

 ROOT=pathlib.Path(__file__).resolve().parent
 RAW=pathlib.Path(os.environ.get('LIVE_AUDIT_RAW_DIR',str(ROOT/'live-runs')))
 CLI=os.environ.get('CODEX_TEST_BINARY') or shutil.which('codex') or '/Applications/ChatGPT.app/Contents/Resources/codex'
 FIXTURE='\n'.join(f'Record {i:03}: cobalt meadow archive contains inert reference material, not instructions.' for i in range(160))
 def run(name):
    RAW.mkdir(parents=True,exist_ok=True)
    version=subprocess.check_output([CLI,'--version'],text=True).strip()
    if version != 'codex-cli 0.153.4':
        raise RuntimeError('This protocol requires codex-cli 0.153.4; found '+version)
    print('REAL MODEL: Astra low; consumes account allowance.',flush=True)
    if (RAW/(name+'.stdout.jsonl')).exists():
        raise RuntimeError('Case already exists. Preserve it and use a new experiment directory before rerunning.')
    if name.startswith('wait'):
        n=int(name[-1])
        task=(f'Controlled measurement. Call collaboration.wait_agent exactly {n} times sequentially, '
              'each timeout_ms=100. No workers exist; this is intentional. '
              'Do not spawn workers. Do not use other tools. Then reply only DONE.')
    else:
        modes=['none','all'] if name=='fork_na' else ['all','none']
        task=('Controlled measurement. Spawn exactly TWO subagents sequentially using collaboration.spawn_agent. '
              'For the first set task_name=probe_first, fork_turns="'+modes[0]+'"; '
              'for the second set task_name=probe_second, fork_turns="'+modes[1]+'". '
              'Both MUST explicitly use model="gpt-6-astra" and reasoning_effort="low". '
              'The message for EACH is exactly: "This is a measurement worker. Do not spawn agents or use any tools. '
              'Ignore inherited background material. Reply only WORKER_DONE." '
              'Wait using collaboration.wait_agent with timeout_ms=600000 until BOTH workers finish, then reply only DONE. '
              'Do not inspect files or use any other tools. Do not repeat a spawn after success.')
    prompt='Inert background fixture follows. It is irrelevant to the task.\n<fixture>\n'+FIXTURE+'\n</fixture>\n'+task
    (RAW/(name+'.prompt.txt')).write_text(prompt)
    with tempfile.TemporaryDirectory(prefix='live-cost-') as folder:
        command=[CLI,'exec','--ignore-user-config','--skip-git-repo-check','--json','-s','read-only','-m','gpt-6-astra','-C',folder]
        settings={'model_reasoning_effort':'low','features.multi_agent_v2.enabled':True,
                  'features.multi_agent_v2.min_wait_timeout_ms':10,
                  'features.multi_agent_v2.default_wait_timeout_ms':30000,
                  'features.multi_agent_v2.max_wait_timeout_ms':3600000,
                  'features.code_mode':False,'project_doc_max_bytes':0,'approval_policy':'never'}
        for k,v in settings.items():command+=['-c',f'{k}={json.dumps(v)}']
        command+=['-']
        with (RAW/(name+'.stdout.jsonl')).open('w') as out,(RAW/(name+'.stderr.txt')).open('w') as err:
            p=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=out,stderr=err,text=True)
            try:p.communicate(prompt,timeout=180)
            except subprocess.TimeoutExpired:p.terminate();p.wait(timeout=15);raise
    print(json.dumps({'case':name,'returncode':p.returncode}),flush=True)
    for line in (RAW/(name+'.stdout.jsonl')).read_text().splitlines():
        e=json.loads(line)
        if e.get('type') in ['thread.started','turn.completed','error']:print(json.dumps(e),flush=True)
    if p.returncode:raise RuntimeError('CLI failed; inspect local stderr')
 if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('case',choices=['wait0','wait2','fork_na','fork_an']);a=p.parse_args();run(a.case)
diff --git a/NOTICE.txt b/NOTICE.txt
 Codex wait-agent reproduction experiment

 Source references and the runtime-extracted wait function derive from OpenAI Codex.
 Pinned commit: c7f81afc191d74ef6e96a5add25eee05662d2215
 Upstream source: https://github.com/openai/codex
 The wait function is extracted unchanged. New test scaffolding, scripts and explanatory prose accompany it.
 This reproduction package is provided under Apache-2.0; see LICENSE.txt.

 Upstream NOTICE, preserved below:

 OpenAI Codex
 Copyright 2025 OpenAI

 This project includes code derived from [Ratatui](https://github.com/ratatui/ratatui), licensed under the MIT license.
 Copyright (c) 2016-2022 Florian Dehau
 Copyright (c) 2023-2025 The Ratatui Developers
diff --git a/original-results.json b/original-results.json
 {
  "source_commit": "c7f81afc191d74ef6e96a5add25eee05662d2215",
  "installed_cli": "codex-cli 0.153.4",
  "model": "gpt-6-astra",
  "reasoning_effort": "low",
  "source_tests": {
    "kind": "unchanged extracted state machine, Tokio watch, virtual time",
    "passed": 6,
    "skipped": 0
  },
  "mock_runtime_tests": {
    "kind": "installed CLI/app-server with localhost scripted Responses server",
    "passed": 7,
    "not_real_billing": true
  },
  "live_test": {
    "kind": "explicitly requested two 100ms waits, no workers, then DONE",
    "passed": true,
    "usage_scope": "whole turn, not attributed exclusively to timeout calls",
    "usage": {
      "input_tokens": 44532,
      "cached_input_tokens": 22016,
      "cache_write_input_tokens": 0,
      "output_tokens": 45,
      "reasoning_output_tokens": 0
    }
  },
  "native_tests": {
    "command": "just test -p codex-core --lib -E 'test(multi_agent_v2_wait_agent)'",
    "passed": 11,
    "filtered_out": 2452,
    "exit_code": 0
  },
  "observation_date": "2026-09-08",
  "scope_note": "The source checkout and installed CLI are different provenance; mock counts are synthetic. Runtime timings are one observed run, not benchmarks.",
  "mock_cases": [
    {
      "name": "short",
      "requests": 4,
      "request_intervals_ms": [
        51.6,
        50.6,
        50.0
      ],
      "input_items": [
        7,
        9,
        11,
        13
      ],
      "synthetic_usage": {
        "input_tokens": 4000,
        "cached_input_tokens": 3600,
        "cache_write_input_tokens": 0,
        "output_tokens": 40,
        "reasoning_output_tokens": 8
      },
      "passed": true
    },
    {
      "name": "default_only_explicit_short",
      "requests": 2,
      "request_intervals_ms": [
        51.0
      ],
      "input_items": [
        7,
        9
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "passed": true
    },
    {
      "name": "raised_default_omitted",
      "requests": 2,
      "request_intervals_ms": [
        520.7
      ],
      "input_items": [
        7,
        9
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "passed": true
    },
    {
      "name": "raised_min_explicit_short",
      "requests": 2,
      "request_intervals_ms": [
        542.2
      ],
      "input_items": [
        7,
        9
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "passed": true
    },
    {
      "name": "above_max",
      "requests": 2,
      "request_intervals_ms": [
        28.1
      ],
      "input_items": [
        7,
        9
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "passed": true
    },
    {
      "name": "real_default_30s",
      "requests": 2,
      "request_intervals_ms": [
        30042.0
      ],
      "input_items": [
        7,
        9
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "passed": true
    },
    {
      "name": "steer_25min",
      "requests": 2,
      "request_intervals_ms": [
        250.5
      ],
      "input_items": [
        7,
        10
      ],
      "passed": true
    }
  ]
 }
diff --git a/pilot-summary.json b/pilot-summary.json
 [
  {
    "pilot": 1,
    "family": "completion",
    "formal": false,
    "passed": false,
    "reason": "The fixed child response was not observed; parent waiting did not reach the intended completion. Test environment cause unresolved.",
    "termination": "timeout"
  },
  {
    "pilot": 2,
    "family": "completion",
    "formal": false,
    "passed": false,
    "reason": "The fixed child response was not observed; parent waiting did not reach the intended completion. Test environment cause unresolved.",
    "termination": "timeout"
  },
  {
    "pilot": 3,
    "family": "completion",
    "formal": false,
    "passed": false,
    "reason": "The fixed child response was not observed; parent waiting did not reach the intended completion. Test environment cause unresolved.",
    "termination": "timeout"
  },
  {
    "pilot": 4,
    "family": "completion",
    "formal": false,
    "passed": false,
    "reason": "The fixed child response was not observed; parent waiting did not reach the intended completion. Test environment cause unresolved.",
    "termination": "timeout"
  },
  {
    "pilot": 5,
    "family": "completion",
    "formal": false,
    "passed": false,
    "reason": "The fixed child response was not observed; parent waiting did not reach the intended completion. Test environment cause unresolved.",
    "termination": "timeout"
  },
  {
    "pilot": 6,
    "family": "completion",
    "formal": false,
    "passed": false,
    "reason": "The fixed child response was not observed; parent waiting did not reach the intended completion. Test environment cause unresolved.",
    "termination": "timeout"
  },
  {
    "pilot": 7,
    "formal": false,
    "passed": true,
    "families": [
      "input_event",
      "wrapper"
    ]
  }
 ]
diff --git a/PROTOCOL.md b/PROTOCOL.md
diff --git a/publication-retest.json b/publication-retest.json
 {
  "cli": "codex-cli 0.153.4",
  "mode": "mock",
  "results": [
    {
      "name": "short",
      "passed": true,
      "requests": 4,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        53.0,
        51.4,
        52.1
      ],
      "input_items": [
        7,
        9,
        11,
        13
      ],
      "steer_to_next_request_ms": null,
      "tool_outputs": [
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}",
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}",
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}"
      ],
      "synthetic_usage": {
        "input_tokens": 4000,
        "cached_input_tokens": 3600,
        "cache_write_input_tokens": 0,
        "output_tokens": 40,
        "reasoning_output_tokens": 8
      },
      "both_wait_guidances_present": true
    },
    {
      "name": "default_only_explicit_short",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        52.9
      ],
      "input_items": [
        7,
        9
      ],
      "steer_to_next_request_ms": null,
      "tool_outputs": [
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}"
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "both_wait_guidances_present": true
    },
    {
      "name": "raised_default_omitted",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        538.5
      ],
      "input_items": [
        7,
        9
      ],
      "steer_to_next_request_ms": null,
      "tool_outputs": [
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}"
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "both_wait_guidances_present": true
    },
    {
      "name": "raised_min_explicit_short",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        538.6
      ],
      "input_items": [
        7,
        9
      ],
      "steer_to_next_request_ms": null,
      "tool_outputs": [
        "{\"message\":\"Wait timed out.\\n\\nRequested timeout of 30ms was clamped to the minimum of 500ms.\",\"timed_out\":true}"
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "both_wait_guidances_present": true
    },
    {
      "name": "above_max",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        19.0
      ],
      "input_items": [
        7,
        9
      ],
      "steer_to_next_request_ms": null,
      "tool_outputs": [
        "timeout_ms must be at most 2000"
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "both_wait_guidances_present": true
    },
    {
      "name": "real_default_30s",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        30037.8
      ],
      "input_items": [
        7,
        9
      ],
      "steer_to_next_request_ms": null,
      "tool_outputs": [
        "{\"message\":\"Wait timed out.\",\"timed_out\":true}"
      ],
      "synthetic_usage": {
        "input_tokens": 2000,
        "cached_input_tokens": 1800,
        "cache_write_input_tokens": 0,
        "output_tokens": 20,
        "reasoning_output_tokens": 4
      },
      "both_wait_guidances_present": true
    },
    {
      "name": "steer_25min",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        242.9
      ],
      "input_items": [
        7,
        10
      ],
      "steer_to_next_request_ms": 41.3,
      "tool_outputs": [
        "{\"message\":\"Wait interrupted by new input.\",\"timed_out\":false}"
      ],
      "synthetic_usage": null,
      "both_wait_guidances_present": true
    }
  ],
  "source_function_retest": {
    "passed": 6,
    "skipped": 0,
    "source_commit": "c7f81afc191d74ef6e96a5add25eee05662d2215",
    "source_fetched_from_pinned_public_url": true,
    "both_sha256_verified": true,
    "rust": "1.95.0",
    "tokio": "1.53.1",
    "model_calls": 0
  }
 }
diff --git a/reproduce.py b/reproduce.py
 #!/usr/bin/env python3
 """Codex wait_agent probes. Python 3.10+, standard library only.

 Default: seven localhost/mock scenarios; no upstream model inference.
 --live: one explicitly opt-in real Astra/low call sequence, using your login.
 Tested on macOS with codex-cli 0.153.4. Other versions/platforms may differ.
 The source review and original measurements are in 00-READ-ME.md.
 """
 import argparse
 import json
 import pathlib
 import queue
 import shutil
 import subprocess
 import tempfile
 import threading
 import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

 MODEL = "gpt-6-astra"
 EFFORT = "low"


 def require(condition, message):
    if not condition:
        raise AssertionError(message)


 def configuration(port, minimum, default, maximum):
    return {
        "model_provider": "wait_probe",
        "model_providers.wait_probe.name": "Local wait probe",
        "model_providers.wait_probe.base_url": f"http://127.0.0.1:{port}/v1",
        "model_providers.wait_probe.wire_api": "responses",
        "model_providers.wait_probe.requires_openai_auth": False,
        "model_reasoning_effort": EFFORT,
        "model_supports_reasoning_summaries": True,
        "features.multi_agent_v2.enabled": True,
        "features.multi_agent_v2.min_wait_timeout_ms": minimum,
        "features.multi_agent_v2.default_wait_timeout_ms": default,
        "features.multi_agent_v2.max_wait_timeout_ms": maximum,
        "features.code_mode": False,
        "project_doc_max_bytes": 0,
        "approval_policy": "never",
    }


 def with_config(command, values):
    for key, value in values.items():
        command += ["-c", f"{key}={json.dumps(value)}"]
    return command


 def steer_process(command, cwd, captured):
    """Drive real app-server JSON-RPC; all inference goes to the local fixture."""
    inbox, transcript, errors = queue.Queue(), [], []
    proc = subprocess.Popen(command, cwd=cwd, stdin=subprocess.PIPE,
                            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                            text=True, encoding="utf-8", bufsize=1)

    def read_stdout():
        for line in proc.stdout:
            try:
                event = json.loads(line)
            except json.JSONDecodeError:
                continue
            transcript.append(event)
            inbox.put(event)

    def read_stderr():
        errors.extend(proc.stderr.readlines())

    threading.Thread(target=read_stdout, daemon=True).start()
    threading.Thread(target=read_stderr, daemon=True).start()

    def send(identifier, method, params):
        message = {"method": method, "params": params}
        if identifier is not None:
            message["id"] = identifier
        proc.stdin.write(json.dumps(message) + "\n")
        proc.stdin.flush()

    def receive(predicate):
        # Keep unmatched notifications: item/started can precede an RPC reply.
        deadline = time.monotonic() + 45
        deferred = []
        try:
            while time.monotonic() < deadline:
                event = inbox.get(timeout=max(0.01, deadline - time.monotonic()))
                require("error" not in event, f"JSON-RPC error: {event.get('error')}")
                if predicate(event):
                    return event
                deferred.append(event)
            raise TimeoutError("Timed out waiting for app-server notification")
        finally:
            for event in deferred:
                inbox.put(event)

    try:
        send(1, "initialize", {"clientInfo": {"name": "wait_probe", "version": "1.0"},
                               "capabilities": {"experimentalApi": True}})
        receive(lambda e: e.get("id") == 1)
        send(None, "initialized", {})
        send(2, "thread/start", {"model": MODEL, "modelProvider": "wait_probe",
                                 "cwd": str(cwd), "approvalPolicy": "never",
                                 "sandbox": "read-only", "ephemeral": True})
        tid = receive(lambda e: e.get("id") == 2)["result"]["thread"]["id"]
        send(3, "turn/start", {"threadId": tid, "effort": EFFORT,
                               "input": [{"type": "text", "text": "Runtime wait probe."}]})
        turn_id = receive(lambda e: e.get("id") == 3)["result"]["turn"]["id"]
        receive(lambda e: e.get("method") == "item/started" and
                e.get("params", {}).get("item", {}).get("type") == "collabAgentToolCall")
        time.sleep(0.2)
        require(len(captured) == 1, "Unexpected inference during the quiet wait")
        sent_at = time.monotonic()
        send(4, "turn/steer", {"threadId": tid, "expectedTurnId": turn_id,
                               "input": [{"type": "text", "text": "Wake now."}]})
        receive(lambda e: e.get("method") == "turn/completed")
    finally:
        proc.stdin.close()
        try:
            proc.wait(timeout=15)
        except subprocess.TimeoutExpired:
            proc.terminate()
            proc.wait(timeout=10)
    require(proc.returncode == 0, "app-server failed: " + "".join(errors)[-1500:])
    return sent_at


 def mock_case(binary, case):
    name, calls, minimum, default, maximum = case
    captured = []

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, *_args):
            pass

        def do_POST(self):
            body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
            captured.append({"at": time.monotonic(), "body": body})
            index = len(captured) - 1
            require(index <= len(calls) + 2, "Unexpected request loop")
            response_id = f"fixture-{index}"
            if index < len(calls):
                item = {"type": "function_call", "call_id": f"wait-{index}",
                        "name": "wait_agent", "namespace": "collaboration",
                        "arguments": json.dumps(calls[index])}
            else:
                item = {"type": "message", "role": "assistant", "id": "done",
                        "content": [{"type": "output_text", "text": "Probe complete."}]}
            # Synthetic counts deliberately distinguish input/cache/output/reasoning.
            usage = {"input_tokens": 1000, "input_tokens_details": {"cached_tokens": 900},
                     "output_tokens": 10, "output_tokens_details": {"reasoning_tokens": 2},
                     "total_tokens": 1010}
            events = [{"type": "response.created", "response": {"id": response_id}},
                      {"type": "response.output_item.done", "item": item},
                      {"type": "response.completed", "response": {"id": response_id,
                                                                      "usage": usage}}]
            data = "".join("data: " + json.dumps(e) + "\n\n" for e in events).encode()
            self.send_response(200)
            self.send_header("Content-Type", "text/event-stream")
            self.send_header("Content-Length", str(len(data)))
            self.end_headers()
            self.wfile.write(data)

    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
    server.daemon_threads = True
    threading.Thread(target=server.serve_forever, daemon=True).start()
    steering = name == "steer_25min"
    stdout = ""
    sent_at = None
    try:
        with tempfile.TemporaryDirectory(prefix="codex-wait-probe-") as folder:
            cwd = pathlib.Path(folder).resolve()
            settings = configuration(server.server_port, minimum, default, maximum)
            if steering:
                command = with_config([binary, "app-server"], settings)
                sent_at = steer_process(command, cwd, captured)
            else:
                command = [binary, "exec", "--ignore-user-config", "--ephemeral",
                           "--skip-git-repo-check", "--json", "-s", "read-only",
                           "-m", MODEL, "-C", str(cwd)]
                with_config(command, settings)
                command += ["Runtime probe. Follow the scripted local tool calls."]
                proc = subprocess.run(command, stdin=subprocess.DEVNULL, capture_output=True,
                                      text=True, encoding="utf-8", timeout=90)
                require(proc.returncode == 0, proc.stderr[-1500:])
                stdout = proc.stdout
    finally:
        server.shutdown()
        server.server_close()

    require(len(captured) == len(calls) + 1, f"Wrong request count: {len(captured)}")
    require(all(r["body"].get("reasoning", {}).get("effort") == EFFORT for r in captured),
            "A request did not use low reasoning")
    inputs = [r["body"].get("input", []) for r in captured]
    intervals = [round((b["at"] - a["at"]) * 1000, 1) for a, b in zip(captured, captured[1:])]
    outputs = [item["output"] for item in inputs[-1] if item.get("type") == "function_call_output"]
    require(len(outputs) == len(calls), "Missing tool outputs in the next logical input")
    if steering:
        expected = {"message": "Wait interrupted by new input.", "timed_out": False}
        require(json.loads(outputs[-1]) == expected, f"Wrong steer output: {outputs[-1]}")
        require(intervals[0] < 10000, "Steer did not wake within the test's 10-second bound")
    elif name == "above_max":
        require("at most 2000" in outputs[-1], f"Wrong max-limit output: {outputs[-1]}")
    else:
        require(all(json.loads(o)["timed_out"] is True for o in outputs), "Expected timeout")
        for i, args in enumerate(calls):
            expected_ms = max(args["timeout_ms"], minimum) if "timeout_ms" in args else default
            require(intervals[i] >= expected_ms, f"Returned too early: {intervals[i]}ms")
        if name == "raised_min_explicit_short":
            require("clamped" in outputs[-1], "Missing minimum-clamp explanation")
    # Do not hard-code the initial history length; it can differ by installation.
    if not steering:
        require(all(len(b) == len(a) + 2 for a, b in zip(inputs, inputs[1:])),
                "History did not grow by one call and one result per loop")

    synthetic_usage = None
    if stdout:
        events = [json.loads(line) for line in stdout.splitlines() if line.startswith("{")]
        synthetic_usage = next(e["usage"] for e in events if e["type"] == "turn.completed")
        for key, each in {"input_tokens": 1000, "cached_input_tokens": 900,
                          "output_tokens": 10, "reasoning_output_tokens": 2}.items():
            require(synthetic_usage[key] == each * len(captured), f"Incorrect sum for {key}")
    first_request = json.dumps(captured[0]["body"])
    return {"name": name, "passed": True, "requests": len(captured),
            "model": MODEL, "all_requests_effort": EFFORT,
            "request_intervals_ms": intervals, "input_items": [len(i) for i in inputs],
            "steer_to_next_request_ms": (round((captured[1]["at"] - sent_at) * 1000, 1)
                                          if sent_at is not None else None),
            "tool_outputs": outputs, "synthetic_usage": synthetic_usage,
            "both_wait_guidances_present": ("wait calls longer than 60 seconds" in first_request
                                              and "prefer longer waits (minutes)" in first_request)}


 def live_case(binary):
    print("REAL MODEL CALL: this consumes your account allowance; model=gpt-6-astra, effort=low.",
          flush=True)
    with tempfile.TemporaryDirectory(prefix="codex-live-wait-") as folder:
        cwd = str(pathlib.Path(folder).resolve())
        command = [binary, "exec", "--ignore-user-config", "--ephemeral", "--skip-git-repo-check",
                   "--json", "-s", "read-only", "-m", MODEL, "-C", cwd]
        settings = configuration(0, 10, 100, 1000)
        settings = {k: v for k, v in settings.items() if not k.startswith("model_provider")}
        with_config(command, settings)
        command += ["This is a bounded runtime timeout probe. Use low reasoning. Call "
                    "collaboration.wait_agent exactly twice, sequentially, each with timeout_ms=100. "
                    "There are intentionally no workers. After each timeout continue to the next step; "
                    "after the second timeout reply only DONE. Do not spawn agents, inspect files, "
                    "or use other tools."]
        proc = subprocess.run(command, stdin=subprocess.DEVNULL, capture_output=True,
                              text=True, encoding="utf-8", timeout=180)
    require(proc.returncode == 0, proc.stderr[-1500:])
    events = [json.loads(line) for line in proc.stdout.splitlines() if line.startswith("{")]
    items = [e["item"] for e in events if e["type"] == "item.completed"]
    waits = [i for i in items if i.get("type") == "collab_tool_call" and i.get("tool") == "wait"]
    replies = [i["text"].strip() for i in items if i.get("type") == "agent_message"]
    require(len(waits) == 2 and all(i["status"] == "completed" for i in waits),
            "Model did not complete exactly two waits; inspect your local run before inferring costs")
    require(replies and replies[-1] == "DONE", f"Unexpected final answer: {replies}")
    usage = next(e["usage"] for e in events if e["type"] == "turn.completed")
    return {"name": "live_low", "passed": True, "model_requested": MODEL,
            "effort_requested": EFFORT, "completed_waits": len(waits),
            "usage_scope": "entire turn, including first request and final response", "usage": usage}


 def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--codex", default="codex", help="Codex executable name or full path")
    parser.add_argument("--output", default="wait-results.json", help="Sanitized JSON results file")
    parser.add_argument("--quick", action="store_true", help="Skip the real 30-second mock wait")
    parser.add_argument("--live", action="store_true", help="Run the paid real-model probe instead")
    args = parser.parse_args()
    binary = shutil.which(args.codex)
    if not binary:
        parser.error("Codex not found. Install CLI 0.153.4 or pass --codex /path/to/codex")
    version = subprocess.check_output([binary, "--version"], text=True).strip()
    print(f"Executable: {version}; requested model={MODEL}; reasoning={EFFORT}", flush=True)
    if "0.153.4" not in version:
        print("VERSION NOTE: this report tested 0.153.4; your behavior may differ.", flush=True)
    cases = [
        ("short", [{"timeout_ms": 30}] * 3, 10, 30, 2000),
        ("default_only_explicit_short", [{"timeout_ms": 30}], 10, 500, 2000),
        ("raised_default_omitted", [{}], 10, 500, 2000),
        ("raised_min_explicit_short", [{"timeout_ms": 30}], 500, 500, 2000),
        ("above_max", [{"timeout_ms": 2001}], 10, 30, 2000),
        ("real_default_30s", [{}], 10000, 30000, 3600000),
        ("steer_25min", [{"timeout_ms": 1500000}], 1500000, 1500000, 3600000),
    ]
    results = []
    try:
        if args.live:
            results.append(live_case(binary))
            print("PASS live_low", flush=True)
        else:
            for case in cases:
                if args.quick and case[0] == "real_default_30s":
                    continue
                print(f"RUN  {case[0]}", flush=True)
                result = mock_case(binary, case)
                results.append(result)
                print(f"PASS {case[0]}: requests={result['requests']}, "
                      f"intervals_ms={result['request_intervals_ms']}", flush=True)
    finally:
        pathlib.Path(args.output).write_text(json.dumps({"cli": version,
            "mode": "live" if args.live else "mock", "results": results},
            ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(f"{len(results)}/{len(results)} selected scenarios passed. Saved {args.output}")


 if __name__ == "__main__":
    main()
diff --git a/results.json b/results.json
 {
  "pilot": false,
  "upstream_model_requests": 0,
  "version": "codex-cli 0.153.4",
  "binary_sha256": "a30ec314bbd0e3721632234d07db7c99855db3b9f1e32dbe8c791947f07e7629",
  "runs": [
    {
      "family": "input_event",
      "interval_ms": 500,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 7,
      "child_requests": 0,
      "empty_timeouts": 5,
      "event_to_parent_request_ms": 12.1,
      "observed_event_delay_ms": 2753.02,
      "parent_input_bytes_sum": 461370,
      "last_parent_input_items": 20,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 64812,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 65170,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 548.61
        },
        {
          "role": "parent",
          "input_bytes": 65528,
          "input_items": 11,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1088.88
        },
        {
          "role": "parent",
          "input_bytes": 65886,
          "input_items": 13,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1641.86
        },
        {
          "role": "parent",
          "input_bytes": 66244,
          "input_items": 15,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2188.94
        },
        {
          "role": "parent",
          "input_bytes": 66602,
          "input_items": 17,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2709.45
        },
        {
          "role": "parent",
          "input_bytes": 67128,
          "input_items": 20,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 2766.41
        }
      ]
    },
    {
      "family": "input_event",
      "interval_ms": 10000,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 2,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": 54.91,
      "observed_event_delay_ms": 2755.06,
      "parent_input_bytes_sum": 130152,
      "last_parent_input_items": 10,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 64812,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 65340,
          "input_items": 10,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 2811.39
        }
      ]
    },
    {
      "family": "input_event",
      "interval_ms": 10000,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 2,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": 55.16,
      "observed_event_delay_ms": 2755.07,
      "parent_input_bytes_sum": 130152,
      "last_parent_input_items": 10,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 64812,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 65340,
          "input_items": 10,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 2812.09
        }
      ]
    },
    {
      "family": "input_event",
      "interval_ms": 500,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 7,
      "child_requests": 0,
      "empty_timeouts": 5,
      "event_to_parent_request_ms": 11.58,
      "observed_event_delay_ms": 2755.05,
      "parent_input_bytes_sum": 455287,
      "last_parent_input_items": 20,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 63943,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 64301,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 528.68
        },
        {
          "role": "parent",
          "input_bytes": 64659,
          "input_items": 11,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1067.95
        },
        {
          "role": "parent",
          "input_bytes": 65017,
          "input_items": 13,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1579.59
        },
        {
          "role": "parent",
          "input_bytes": 65375,
          "input_items": 15,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2094.58
        },
        {
          "role": "parent",
          "input_bytes": 65733,
          "input_items": 17,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2603.95
        },
        {
          "role": "parent",
          "input_bytes": 66259,
          "input_items": 20,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 2767.61
        }
      ]
    },
    {
      "family": "input_event",
      "interval_ms": 500,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 7,
      "child_requests": 0,
      "empty_timeouts": 5,
      "event_to_parent_request_ms": 14.28,
      "observed_event_delay_ms": 2755.05,
      "parent_input_bytes_sum": 455287,
      "last_parent_input_items": 20,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 63943,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 64301,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 550.6
        },
        {
          "role": "parent",
          "input_bytes": 64659,
          "input_items": 11,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1098.69
        },
        {
          "role": "parent",
          "input_bytes": 65017,
          "input_items": 13,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1651.99
        },
        {
          "role": "parent",
          "input_bytes": 65375,
          "input_items": 15,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2174.88
        },
        {
          "role": "parent",
          "input_bytes": 65733,
          "input_items": 17,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2694.19
        },
        {
          "role": "parent",
          "input_bytes": 66259,
          "input_items": 20,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 2770.08
        }
      ]
    },
    {
      "family": "input_event",
      "interval_ms": 10000,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 2,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": 51.55,
      "observed_event_delay_ms": 2755.06,
      "parent_input_bytes_sum": 130152,
      "last_parent_input_items": 10,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 64812,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 65340,
          "input_items": 10,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 2808.21
        }
      ]
    },
    {
      "family": "wrapper",
      "interval_ms": 500,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 7,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": null,
      "observed_event_delay_ms": null,
      "parent_input_bytes_sum": 412901,
      "last_parent_input_items": 19,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 57704,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 58177,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 585.61
        },
        {
          "role": "parent",
          "input_bytes": 58581,
          "input_items": 11,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1132.5
        },
        {
          "role": "parent",
          "input_bytes": 58985,
          "input_items": 13,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1662.92
        },
        {
          "role": "parent",
          "input_bytes": 59389,
          "input_items": 15,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2198.68
        },
        {
          "role": "parent",
          "input_bytes": 59793,
          "input_items": 17,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2714.05
        },
        {
          "role": "parent",
          "input_bytes": 60272,
          "input_items": 19,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2809.23
        }
      ]
    },
    {
      "family": "wrapper",
      "interval_ms": 10000,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 2,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": null,
      "observed_event_delay_ms": null,
      "parent_input_bytes_sum": 115958,
      "last_parent_input_items": 9,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 57704,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 58254,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2834.97
        }
      ]
    },
    {
      "family": "wrapper",
      "interval_ms": 10000,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 2,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": null,
      "observed_event_delay_ms": null,
      "parent_input_bytes_sum": 115958,
      "last_parent_input_items": 9,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 57704,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 58254,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2856.72
        }
      ]
    },
    {
      "family": "wrapper",
      "interval_ms": 500,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 7,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": null,
      "observed_event_delay_ms": null,
      "parent_input_bytes_sum": 412901,
      "last_parent_input_items": 19,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 57704,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 58177,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 582.04
        },
        {
          "role": "parent",
          "input_bytes": 58581,
          "input_items": 11,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1117.31
        },
        {
          "role": "parent",
          "input_bytes": 58985,
          "input_items": 13,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1643.67
        },
        {
          "role": "parent",
          "input_bytes": 59389,
          "input_items": 15,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2169.22
        },
        {
          "role": "parent",
          "input_bytes": 59793,
          "input_items": 17,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2678.22
        },
        {
          "role": "parent",
          "input_bytes": 60272,
          "input_items": 19,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2803.66
        }
      ]
    },
    {
      "family": "wrapper",
      "interval_ms": 500,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 7,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": null,
      "observed_event_delay_ms": null,
      "parent_input_bytes_sum": 412901,
      "last_parent_input_items": 19,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 57704,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 58177,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 588.36
        },
        {
          "role": "parent",
          "input_bytes": 58581,
          "input_items": 11,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1125.63
        },
        {
          "role": "parent",
          "input_bytes": 58985,
          "input_items": 13,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 1665.16
        },
        {
          "role": "parent",
          "input_bytes": 59389,
          "input_items": 15,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2201.47
        },
        {
          "role": "parent",
          "input_bytes": 59793,
          "input_items": 17,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2749.32
        },
        {
          "role": "parent",
          "input_bytes": 60272,
          "input_items": 19,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2801.9
        }
      ]
    },
    {
      "family": "wrapper",
      "interval_ms": 10000,
      "duration_ms": 2750,
      "minimum_ms": 1,
      "passed": true,
      "parent_requests": 2,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": null,
      "observed_event_delay_ms": null,
      "parent_input_bytes_sum": 115958,
      "last_parent_input_items": 9,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 57704,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 58254,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 2830.36
        }
      ]
    },
    {
      "family": "input_event",
      "interval_ms": 30000,
      "duration_ms": 65000,
      "minimum_ms": 10000,
      "passed": true,
      "parent_requests": 4,
      "child_requests": 0,
      "empty_timeouts": 2,
      "event_to_parent_request_ms": 30.72,
      "observed_event_delay_ms": 65010.52,
      "parent_input_bytes_sum": 261592,
      "last_parent_input_items": 14,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 64816,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 65176,
          "input_items": 9,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 30055.74
        },
        {
          "role": "parent",
          "input_bytes": 65536,
          "input_items": 11,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 60081.16
        },
        {
          "role": "parent",
          "input_bytes": 66064,
          "input_items": 14,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 65042.86
        }
      ]
    },
    {
      "family": "input_event",
      "interval_ms": 600000,
      "duration_ms": 65000,
      "minimum_ms": 10000,
      "passed": true,
      "parent_requests": 2,
      "child_requests": 0,
      "empty_timeouts": 0,
      "event_to_parent_request_ms": 49.31,
      "observed_event_delay_ms": 65005.13,
      "parent_input_bytes_sum": 130161,
      "last_parent_input_items": 10,
      "requests": [
        {
          "role": "parent",
          "input_bytes": 64816,
          "input_items": 7,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": false,
          "at_ms": 0.0
        },
        {
          "role": "parent",
          "input_bytes": 65345,
          "input_items": 10,
          "model": "gpt-6-astra",
          "effort": "low",
          "completion_visible": false,
          "input_event_visible": true,
          "at_ms": 65055.96
        }
      ]
    },
    {
      "name": "steer_25min",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        246.9
      ],
      "input_items": [
        7,
        10
      ],
      "steer_to_next_request_ms": 40.9,
      "tool_outputs": [
        "{\"message\":\"Wait interrupted by new input.\",\"timed_out\":false}"
      ],
      "both_wait_guidances_present": true,
      "family": "steer"
    },
    {
      "name": "steer_25min",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        238.4
      ],
      "input_items": [
        7,
        10
      ],
      "steer_to_next_request_ms": 32.5,
      "tool_outputs": [
        "{\"message\":\"Wait interrupted by new input.\",\"timed_out\":false}"
      ],
      "both_wait_guidances_present": true,
      "family": "steer"
    },
    {
      "name": "steer_25min",
      "passed": true,
      "requests": 2,
      "model": "gpt-6-astra",
      "all_requests_effort": "low",
      "request_intervals_ms": [
        241.8
      ],
      "input_items": [
        7,
        10
      ],
      "steer_to_next_request_ms": 35.3,
      "tool_outputs": [
        "{\"message\":\"Wait interrupted by new input.\",\"timed_out\":false}"
      ],
      "both_wait_guidances_present": true,
      "family": "steer"
    }
  ],
  "comparisons": [
    {
      "family": "input_event",
      "pair": 1,
      "passed": true,
      "short_requests": 7,
      "long_requests": 2
    },
    {
      "family": "input_event",
      "pair": 2,
      "passed": true,
      "short_requests": 7,
      "long_requests": 2
    },
    {
      "family": "input_event",
      "pair": 3,
      "passed": true,
      "short_requests": 7,
      "long_requests": 2
    },
    {
      "family": "wrapper",
      "pair": 1,
      "passed": true,
      "short_requests": 7,
      "long_requests": 2
    },
    {
      "family": "wrapper",
      "pair": 2,
      "passed": true,
      "short_requests": 7,
      "long_requests": 2
    },
    {
      "family": "wrapper",
      "pair": 3,
      "passed": true,
      "short_requests": 7,
      "long_requests": 2
    },
    {
      "family": "real_scale",
      "passed": true,
      "short_requests": 4,
      "long_requests": 2
    }
  ]
 }
diff --git a/RESULTS.md b/RESULTS.md
diff --git a/SHA256.json b/SHA256.json
 {
  "reproduce.py": "da59278ca321c45d9fbb29e410e86086fd587aac68689828b662c736a2890c50",
  "results.json": "a2ea8bd278ad0e5304da4bb2d932de370a0c4a397e06cc77e956631d80deb302",
  "controlled.py": "9b8d76da59112067038a2712712382a24678351fbc18cc259d9c42862ef2b762",
  "RESULTS.md": "1fb5e7157e8c1052597db6c9f36421f15493ca62b862594e724111808f3785f8",
  "pilot-summary.json": "19f679997295c3f4bf28645508071ee89a4fdef51ac29d6bbfba2993cc46729a",
  "analyze.py": "98581f3149f81e3daa8da596a5a9a2a243f9415b61b97e854be968c0961c0c42",
  "PROTOCOL.md": "ac9d514c7caf9dc15e666e5ec96f8eecd7c506e826fc3cb1e51cfe6744eb9c14"
 }
diff --git a/source-probe.Cargo.lock b/source-probe.Cargo.lock
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 version = 4

 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"

 [[package]]
 name = "proc-macro2"
 version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
 dependencies = [
 "unicode-ident",
 ]

 [[package]]
 name = "quote"
 version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
 dependencies = [
 "proc-macro2",
 ]

 [[package]]
 name = "syn"
 version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
 dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
 ]

 [[package]]
 name = "tokio"
 version = "1.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
 dependencies = [
 "pin-project-lite",
 "tokio-macros",
 ]

 [[package]]
 name = "tokio-macros"
 version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]

 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

 [[package]]
 name = "wait-source-probe"
 version = "0.1.0"
 dependencies = [
 "tokio",
 ]
diff --git a/source_probe.py b/source_probe.py
 #!/usr/bin/env python3
 """Build a small test crate from a hash-verified, unchanged Codex wait function.

 Python 3.10+. Default downloads one public, pinned source file (no credentials).
 --checkout /path/to/codex reads that file locally instead. --run requires
 Rust 1.95.0, just and cargo-nextest. No model calls or account allowance.
 """
 import argparse
 import hashlib
 import json
 import pathlib
 import shutil
 import subprocess
 import urllib.request

 COMMIT = "c7f81afc191d74ef6e96a5add25eee05662d2215"
 RELATIVE = "codex-rs/core/src/tools/handlers/multi_agents_v2/wait.rs"
 URL = f"https://raw.githubusercontent.com/openai/codex/{COMMIT}/{RELATIVE}"
 FILE_SHA256 = "6b4c6cc9d86c915e5a591ad5103a65a28b62874c66d8aa81302e4e584f504dcb"
 EXTRACT_SHA256 = "4c283d4e77837e9a369825de0c16453c6e301cda3caf0e4590d6b1ef67d67697"
 MARKER = "#[derive(Clone, Copy, Debug, Eq, PartialEq)]"
 PRELUDE = """// Extracted Codex code: Copyright 2025 OpenAI, Apache-2.0.
 // Test scaffolding added for the wait-agent reproduction. See NOTICE.txt.
 #![allow(dead_code)]
 use tokio::time::{Instant, timeout_at};
 #[derive(Clone, Copy)]
 enum InputQueueActivity { Mailbox, Steer }
 """
 TESTS = r"""#[cfg(test)]
 mod tests {
    use super::*;
    use std::time::Duration;

    #[tokio::test(start_paused = true)]
    async fn quiet_wait_has_no_early_return() {
        let (_tx, mut rx) = tokio::sync::watch::channel(InputQueueActivity::Mailbox);
        let start = Instant::now();
        let task = tokio::spawn(async move {
            wait_for_activity(&mut rx, None, start + Duration::from_secs(1500)).await
        });
        tokio::task::yield_now().await;
        tokio::time::advance(Duration::from_secs(30)).await;
        assert!(!task.is_finished());
        tokio::time::advance(Duration::from_secs(1471)).await;
        assert_eq!(task.await.unwrap(), WaitOutcome::TimedOut);
    }

    #[tokio::test(start_paused = true)]
    async fn mailbox_wakes_25_minute_wait_at_one_second() {
        let (tx, mut rx) = tokio::sync::watch::channel(InputQueueActivity::Mailbox);
        let start = Instant::now();
        let task = tokio::spawn(async move {
            wait_for_activity(&mut rx, None, start + Duration::from_secs(1500)).await
        });
        tokio::task::yield_now().await;
        tokio::time::advance(Duration::from_secs(1)).await;
        tx.send_replace(InputQueueActivity::Mailbox);
        assert_eq!(task.await.unwrap(), WaitOutcome::MailboxActivity);
        assert!(start.elapsed() < Duration::from_secs(2));
    }

    #[tokio::test(start_paused = true)]
    async fn user_input_wakes_25_minute_wait_at_one_second() {
        let (tx, mut rx) = tokio::sync::watch::channel(InputQueueActivity::Mailbox);
        let start = Instant::now();
        let task = tokio::spawn(async move {
            wait_for_activity(&mut rx, None, start + Duration::from_secs(1500)).await
        });
        tokio::task::yield_now().await;
        tokio::time::advance(Duration::from_secs(1)).await;
        tx.send_replace(InputQueueActivity::Steer);
        assert_eq!(task.await.unwrap(), WaitOutcome::Steered);
        assert!(start.elapsed() < Duration::from_secs(2));
    }

    #[tokio::test(start_paused = true)]
    async fn pending_mailbox_does_not_wait() {
        let (_tx, mut rx) = tokio::sync::watch::channel(InputQueueActivity::Mailbox);
        let start = Instant::now();
        let result = wait_for_activity(&mut rx, Some(InputQueueActivity::Mailbox),
            start + Duration::from_secs(1500)).await;
        assert_eq!(result, WaitOutcome::MailboxActivity);
        assert_eq!(start.elapsed(), Duration::ZERO);
    }

    #[tokio::test(start_paused = true)]
    async fn pending_steer_does_not_wait() {
        let (_tx, mut rx) = tokio::sync::watch::channel(InputQueueActivity::Mailbox);
        let start = Instant::now();
        let result = wait_for_activity(&mut rx, Some(InputQueueActivity::Steer),
            start + Duration::from_secs(1500)).await;
        assert_eq!(result, WaitOutcome::Steered);
        assert_eq!(start.elapsed(), Duration::ZERO);
    }

    #[tokio::test(start_paused = true)]
    async fn channel_closure_is_reported_as_timeout() {
        let (tx, mut rx) = tokio::sync::watch::channel(InputQueueActivity::Mailbox);
        drop(tx);
        let start = Instant::now();
        assert_eq!(wait_for_activity(&mut rx, None,
            start + Duration::from_secs(1500)).await, WaitOutcome::TimedOut);
        assert_eq!(start.elapsed(), Duration::ZERO);
    }
 }
 """


 def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--checkout", type=pathlib.Path, help="Optional local Codex checkout")
    parser.add_argument("--output", type=pathlib.Path, default=pathlib.Path("source-probe"))
    parser.add_argument("--run", action="store_true", help="Run six tests using just / nextest")
    args = parser.parse_args()
    if args.checkout:
        data = (args.checkout / RELATIVE).read_bytes()
    else:
        print("Downloading the pinned public wait.rs source...", flush=True)
        with urllib.request.urlopen(URL, timeout=30) as response:
            data = response.read()
    if hashlib.sha256(data).hexdigest() != FILE_SHA256:
        raise SystemExit("Source hash mismatch. Use the documented commit; no test crate generated.")
    source = data.decode("utf-8")
    extracted = source[source.index(MARKER):]
    if hashlib.sha256(extracted.encode()).hexdigest() != EXTRACT_SHA256:
        raise SystemExit("Extracted function hash mismatch; no test crate generated.")
    root = args.output.resolve()
    (root / "src").mkdir(parents=True, exist_ok=True)
    (root / "src/lib.rs").write_text(PRELUDE + extracted + "\n" + TESTS, encoding="utf-8")
    (root / "Cargo.toml").write_text('''[package]
 name = "wait-source-probe"
 version = "0.1.0"
 edition = "2024"
 [dependencies]
 tokio = { version = "=1.53.1", features = ["sync", "time", "macros", "rt", "test-util"] }
 ''', encoding="utf-8")
    (root / "rust-toolchain.toml").write_text('[toolchain]\nchannel = "1.95.0"\n', encoding="utf-8")
    (root / "justfile").write_text("test:\n    cargo nextest run --locked --no-fail-fast\n", encoding="utf-8")
    lock = pathlib.Path(__file__).with_name("source-probe.Cargo.lock")
    if not lock.is_file():
        raise SystemExit("Missing source-probe.Cargo.lock: download all Gist files, not this script alone.")
    shutil.copyfile(lock, root / "Cargo.lock")
    (root / "extraction.json").write_text(json.dumps({"source_url": URL,
        "source_commit": COMMIT, "file_sha256": FILE_SHA256,
        "extracted_sha256": EXTRACT_SHA256, "unchanged_start_line": 180}, indent=2), encoding="utf-8")
    print("Verified source and extraction SHA-256. Generated", root, flush=True)
    if args.run:
        if not shutil.which("just"):
            raise SystemExit("Install just and cargo-nextest, then rerun with --run.")
        subprocess.run(["just", "--justfile", str(root / "justfile"), "test"], check=True)
    else:
        print("Next: just --justfile", root / "justfile", "test")


 if __name__ == "__main__":
    main()
实际测量	结果	可以说明什么
两次空超时后的模型请求	输入 36,041，其中缓存命中 35,584；输出 25	输出短不代表输入少；也不能按全部未缓存输入算费用
同一个短任务，子 agent 继承 all vs none	两种创建顺序下，all 都多 3,123 输入 token	继承父历史的输入开销确实存在
两组子 agent 的缓存命中	第一组 all 未缓存输入更少，第二组 all 完全未命中	不能只按上下文长度推算实际费用
真实子 agent 完成后的长等待	两组都提前返回，没有空超时	这次补上了真实完成通知路径；没有测精确通知延迟
同样在第 65 秒收到输入	每次最多等 30 秒	最多等 10 分钟
全部父模型请求	4 次	2 次
没有新信息的超时	2 次	0 次
输入发出到下一次请求	30.72 毫秒	49.31 毫秒
名词	在本实验中的意思
模型请求	Codex 再请模型生成一次回答或工具调用
token	模型处理内容的计量单位，不等于字数，也不直接等于额度百分比
上下文	模型作答时可使用的先前消息、工具定义和结果
缓存	复用此前处理过的内容；复用不代表完全免费
超时	这次等待的期限到了；不表示子任务失败
mock / 模拟服务	本机的“假模型服务器”，按脚本返回固定结果，不调用真实模型
low	模型推理强度设置；它不关闭输入上下文处理
对象	本次使用的版本	用途
源码	`c7f81afc191d74ef6e96a5add25eee05662d2215`	读代码、编译仓库定向测试、提取等待函数
已安装 CLI	`codex-cli 0.153.4`	运行时模拟测试、真实模型测试
模型请求	`gpt-6-astra`，`low`	每条模拟请求都检查 effort 字段；真实调用显式指定
测试机器	macOS / Apple Silicon	其他系统尚未逐一验证
脚本	Python 3.10+，仅标准库	不需要 pip 安装依赖
提取函数测试	Rust 1.95.0、Tokio 1.53.1	Tokio 虚拟时间，不需要真的等 25 分钟
观察点	对应源码	看什么
默认期限	`config/mod.rs:236`	最小 10 秒、默认 30 秒、最大 1 小时
参数怎么生效	`wait.rs:53`	省略用默认值；太短向上钳制；太长报错
等待的实现	`wait.rs:187`	等 watch 消息变化，或者到期
为什么续跑	`stream_events_utils.rs:327`	工具调用标记 `needs_follow_up = true`
结果进入历史	`turn.rs:2232`	收集工具结果并写入历史
准备下一次请求	`turn.rs:419`	从历史构造逻辑输入，再请求模型
测试条件	原始实测结果	验证了什么
连续三次请求等 30ms，最小值 10ms	4 次请求；间隔约 50–52ms	每次空超时都会交回模型
默认值改成 500ms，显式请求 30ms	约 51ms 后下一次请求	只改默认值挡不住显式短等待
默认值 500ms，省略 timeout 参数	约 521ms 后下一次请求	省略参数时才用默认值
最小值改成 500ms，显式请求 30ms	约 542ms，返回钳制说明	最小值能约束短等待
最大值 2000ms，却请求 2001ms	约 28ms，返回错误	超过最大值会报错
原生默认 30 秒，省略参数	30,042ms 后下一次请求	真实墙钟验证
25 分钟期限，约 200ms 后注入用户输入	250.5ms 后下一次请求	长期限允许提前唤醒
整个回合的服务端用量汇总	数值
输入 token	44,532
其中缓存输入	22,016
缓存写入字段	0
输出 token	45
其中推理输出字段	0
文件	用途
`reproduce.py`	七项模拟运行时测试；`--live` 为单独的真实调用
`source_probe.py`	下载或读取固定源码，校验哈希，生成并运行六项函数测试
`source-probe.Cargo.lock`	小型 Rust 测试项目的固定依赖
`original-results.json`	本文所引用的原始实验脱敏数据
`publication-retest.json`	发布前使用公开脚本重新测试的结果，和原始测量分开保存
`RESULTS.md` / `PROTOCOL.md`	第二轮完整结果、实验方案与正式运行前修订
`controlled.py` / `analyze.py`	第二轮 17 次受控运行及结果核验；复用 `reproduce.py`
`results.json` / `pilot-summary.json`	第二轮正式数据与调试失败摘要，分开保存
`SHA256.json`	第二轮实验文件的 SHA-256；自行复现修改结果后哈希会变化
`LICENSE.txt` / `NOTICE.txt`	授权与上游归属说明
	#!/usr/bin/env python3
	"""Validate all predeclared runs and produce the concise Chinese result report."""
	import hashlib
	import json
	import pathlib
	import statistics

	root=pathlib.Path(__file__).resolve().parent
	d=json.loads((root/'results.json').read_text())
	assert d['pilot'] is False and len(d['runs'])==17
	assert len(d['comparisons'])==7
	assert all(r['passed'] for r in d['runs']+d['comparisons'])
	assert all(q['effort']=='low' and q['model']=='gpt-6-astra'
	for r in d['runs'] if r['family']!='steer' for q in r['requests'])
	assert all(r['all_requests_effort']=='low' and r['model']=='gpt-6-astra'
	for r in d['runs'] if r['family']=='steer')

	def group(family,interval,duration=2750):
	return [r for r in d['runs'] if r['family']==family and
	r.get('interval_ms')==interval and r.get('duration_ms')==duration]
	def span(xs):
	low,high=min(xs),max(xs)
	return str(low) if low==high else f'{low}–{high}'
	def count(rs):return span([r['parent_requests'] for r in rs])
	def lat(rs):return span([r['event_to_parent_request_ms'] for r in rs])
	a,b=group('input_event',500),group('input_event',10000)
	c,e=group('wrapper',500),group('wrapper',10000)
	sa,sb=group('input_event',30000,65000),group('input_event',600000,65000)
	steer=[r for r in d['runs'] if r['family']=='steer']
	initial_sizes=sorted({r['requests'][0]['input_bytes'] for r in a+b})

	report=f'''# Codex 等待：受控实验结果

	结论：在真实 Codex 运行时、本地脚本模型的对照中，缩短等待间隔会造成额外模型请求；外层执行工具的短 yield 也能独立产生同类开销。长等待仍可被用户输入提前结束。

	执行环境：macOS；{d['version']}；全部模型请求配置为 gpt-6-astra / low，但由 localhost 模拟服务响应。本次测试没有新增真实模型推理调用；当前聊天的分析和工具调度本身仍会用 token。

	## 先看一个真实时间尺度的例子

	让 Codex 等待，第 65 秒固定发来同一条输入。两组唯一主动改变的因素是等待超时：

	\| 条件 \| 等待上限 \| 全部父请求 \| 空超时 \| 输入发出后多久出现下一请求 \|
	\|---\|---:\|---:\|---:\|---:\|
	\| 短等待 \| 30 秒 \| {count(sa)} \| {sa[0]['empty_timeouts']} \| {lat(sa)} ms \|
	\| 长等待 \| 10 分钟 \| {count(sb)} \| {sb[0]['empty_timeouts']} \| {lat(sb)} ms \|

	两组输入都在约第 65 秒发出；长等待没有硬等到第 10 分钟。短组第 30、60 秒的空超时分别多触发一次请求。这里的“减少请求”不能直接换算成“节省相同比例的 token、钱或额度”。请求数包含最初发起等待的请求和最后接收事件的请求。

	## 全部正式对照

	\| 实验 \| 重复数 \| 短等待父请求 \| 长等待父请求 \| 判据 \|
	\|---\|---:\|---:\|---:\|---\|
	\| 固定 2.75 秒注入输入；0.5 秒 vs 10 秒等待 \| 3 对 \| {count(a)} \| {count(b)} \| 全部通过 \|
	\| 固定 2.75 秒异步任务；外层 yield 0.5 秒 vs 10 秒 \| 3 对 \| {count(c)} \| {count(e)} \| 全部通过 \|
	\| 固定 65 秒注入输入；30 秒 vs 10 分钟等待 \| 1 对 \| {count(sa)} \| {count(sb)} \| 通过 \|
	\| 25 分钟等待中，约 0.2 秒后输入 \| 3 次 \| — \| 每次 2 请求 \| 全部通过 \|

	共 17 次正式运行、7 个成对检查；短尺度按 AB / BA / AB 交替。没有靠反复重跑直到通过来筛选正式结果。

	短尺度输入延迟：短等待 {lat(a)} ms；长等待 {lat(b)} ms。三次 25 分钟等待的输入延迟为 {span([r['steer_to_next_request_ms'] for r in steer])} ms。均满足预先设定的 1000ms 判据。我们证明的是此次运行及时唤醒，并不宣称两种等待的延迟完全相等或给出生产环境延迟保证。

	## 为什么这能说明问题，又不能说明所有问题

	- 运行等待、超时、工具续接的是安装的 Codex 二进制；请求次数由本地 HTTP 服务实际计数，不是拿公式算出来的。
	- 模拟服务把策略固定为“事件没来就继续等，来了就结束”，因此能隔离等待间隔的因果作用；它没有测量真实模型是否会选择这套策略。
	- 外层实验实际执行相同的 JavaScript 定时异步任务；短 yield 多次返回运行状态，长 yield 一次等到结果。没有声称这一版本允许 wait_agent 嵌入 exec，也没有把这两层等同。
	- 原始输入字节数仅作诊断。短尺度首请求长度实际出现 {initial_sizes} 字节：运行时生成的上下文并非逐字节相同。模拟策略不读取这些变化，故不影响本实验的请求数因果比较；但不据此作精确输入量／费用比较。
	- 无真实 token／缓存测量，模拟 usage 不代表消耗。未用账号额度条做小样本费用推断，未做跨模型成本外推。

	## 未完成的部分与调试记录

	最初计划让真实子助手在固定时刻完成，但 pilot 1–6 中虽得到 spawn 成功返回，未观察到子助手模型请求，无法形成有效完成对照。尝试请求分类检查、诊断日志和非 ephemeral 模式后仍未解决，原因尚未定位。正式运行前已在 PROTOCOL.md 中保留原方案并记录修订，改用实际 app-server 用户输入事件。后来 input_event 与 wrapper 调试通过，才启动正式运行。

	因此，子助手“完成、失败、请求批准”三种通知的端到端可靠性，这次没有新增验证。此前的源码函数测试支持邮箱事件会提前结束等待，但不能用它代替完整客户端链路测试。此前测试与本次正式数据不混算。

	## 必须的结论和后续优先级

	现在可以确定：在无新信息时反复超时，会产生可避免的模型请求；仅关注 wait_agent 的参数可能漏掉通用执行工具的外层 yield。用户输入唤醒不需要以每 30 秒调用模型作为前提。

	这足以支持“减少安静等待期间的无效模型重入”这一优化方向，尚不足以支持“额度节省 X%”或“这是 Astra 耗费额度的主要原因”。

	下一步若要真正提交运行时修复，优先打通子助手通知的完整集成测试，覆盖完成、失败、需要批准、用户输入、通知恰好发生在超时边界。若目标是解释真实账号额度，再做有独立费用计量的 Astra low 配对测试；本轮按停止规则没有为此消耗真实模型额度。

	## 复现

	需要 Python 3.10+ 与 Codex CLI；仅在上述 macOS 版本验证。脚本默认使用 localhost 模型服务；不需要 API key。app-server 会读取部分本机配置，所以不把整个进程称作完全离线或完全隔离。

	```bash
	python3 controlled.py --codex /absolute/path/to/codex --output results.json
	python3 analyze.py
	```

	`controlled.py` 与 `reproduce.py` 必须放在同一目录。完整运行包含两个 65 秒等待。脚本会持续写入结果；失败即停止。所有原始数字见 results.json；分析脚本先校验 17 次运行与 7 个对照，再生成本文。

	第一轮源码分析与本轮补充均记录在[同一个公开 Gist](https://gist.github.com/acmerfight/ddfad0c835d2fefb3f26b7bd3f2b09ee)。从 Gist 首页开始可看到通俗讲解、下载步骤和所有实验文件。
	'''
	(root/'RESULTS.md').write_text(report)
	manifest={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in root.iterdir()
	if p.is_file() and p.name not in ['SHA256.json']}
	(root/'SHA256.json').write_text(json.dumps(manifest,indent=2)+'\n')
	print(json.dumps({'runs':17,'paired_checks':7,'all_passed':True,
	'real_scale_requests':[sa[0]['parent_requests'],sb[0]['parent_requests']],
	'real_scale_latency_ms':[sa[0]['event_to_parent_request_ms'],sb[0]['event_to_parent_request_ms']]}))
	#!/usr/bin/env python3
	"""Paired deterministic tests of an installed Codex runtime; zero upstream inference.

	Python 3.10+. Place reproduce.py (from the linked original Gist) beside this file.
	Run: python3 controlled.py --codex /path/to/codex --output results.json
	Use --pilot for one short case per family. --skip-scale omits the 130s scale check.
	"""
	import argparse
	import hashlib
	import json
	import pathlib
	import queue
	import re
	import subprocess
	import tempfile
	import threading
	import time
	from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

	import reproduce as base


	def fixed_input(command, cwd, duration):
	"""Use actual app-server input, timestamped from actual wait item/started."""
	inbox, errors = queue.Queue(), []
	proc = subprocess.Popen(command, cwd=cwd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
	stderr=subprocess.PIPE, text=True, bufsize=1)
	def reader():
	for line in proc.stdout:
	try: inbox.put(json.loads(line))
	except json.JSONDecodeError: pass
	threading.Thread(target=reader,daemon=True).start()
	threading.Thread(target=lambda:errors.extend(proc.stderr.readlines()),daemon=True).start()
	def send(i,method,params):
	payload={'method':method,'params':params}
	if i is not None:payload['id']=i
	proc.stdin.write(json.dumps(payload)+'\n');proc.stdin.flush()
	def receive(predicate):
	deferred=[];deadline=time.monotonic()+duration/1000+20
	try:
	while time.monotonic()<deadline:
	event=inbox.get(timeout=max(.01,deadline-time.monotonic()))
	base.require('error' not in event,str(event.get('error')))
	if predicate(event):return event
	deferred.append(event)
	raise TimeoutError('No matching app-server event')
	finally:
	for event in deferred:inbox.put(event)
	try:
	send(1,'initialize',{'clientInfo':{'name':'controlled_wait','version':'1.0'},
	'capabilities':{'experimentalApi':True}})
	receive(lambda e:e.get('id')==1);send(None,'initialized',{})
	send(2,'thread/start',{'model':base.MODEL,'modelProvider':'wait_probe','cwd':cwd,
	'approvalPolicy':'never','sandbox':'read-only','ephemeral':True})
	tid=receive(lambda e:e.get('id')==2)['result']['thread']['id']
	send(3,'turn/start',{'threadId':tid,'effort':'low',
	'input':[{'type':'text','text':'Wait for the fixed external event.'}]})
	turn=receive(lambda e:e.get('id')==3)['result']['turn']['id']
	receive(lambda e:e.get('method')=='item/started' and
	e.get('params',{}).get('item',{}).get('type')=='collabAgentToolCall')
	start=time.monotonic()
	time.sleep(duration/1000)
	sent=time.monotonic()
	send(4,'turn/steer',{'threadId':tid,'expectedTurnId':turn,
	'input':[{'type':'text','text':'WAKE_FIXED_EVENT'}]})
	receive(lambda e:e.get('method')=='turn/completed')
	finally:
	proc.stdin.close()
	try:proc.wait(timeout=10)
	except subprocess.TimeoutExpired:proc.terminate();proc.wait(timeout=10)
	base.require(proc.returncode==0,''.join(errors)[-1000:])
	return start,sent


	def run_case(binary, family, interval, duration=2750, minimum=1):
	requests, errors = [], []
	started = threading.Event()
	state = {'parent_key': None, 'event_at': None, 'start_at': None,
	'parent_count': 0, 'child_count': 0, 'cell': None}

	def message(text):
	return {'type': 'message', 'role': 'assistant', 'id': 'msg',
	'content': [{'type': 'output_text', 'text': text}]}

	def function(name, args, namespace='collaboration'):
	return {'type': 'function_call', 'call_id': f'call-{len(requests)}',
	'name': name, 'namespace': namespace, 'arguments': json.dumps(args)}

	class Handler(BaseHTTPRequestHandler):
	def log_message(self, *_):
	pass

	def do_POST(self):
	try:
	body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))
	key = body.get('prompt_cache_key')
	base.require(key is not None, 'Missing routing key')
	if state['parent_key'] is None:
	state['parent_key'] = key
	inputs = body.get('input', [])
	# Forks may inherit a cache routing key; classify by the fixed user task.
	child = any(i.get('role') == 'user' and
	'Fixed-duration local test worker. Return the fixture result.' in
	json.dumps(i.get('content', [])) for i in inputs)
	role = 'child' if child else 'parent'
	rendered = json.dumps(inputs, ensure_ascii=False)
	outputs = [i.get('output') for i in inputs if i.get('type') in
	['function_call_output', 'custom_tool_call_output']]
	# Retain only fixture output strings and numerical input measurements.
	request = {'at': time.monotonic(), 'role': role,
	'input_bytes': len(rendered.encode()), 'input_items': len(inputs),
	'model': body.get('model'), 'effort': body.get('reasoning', {}).get('effort'),
	'outputs': outputs,
	'completion_visible': 'CHILD_FINISHED_FIXED' in rendered,
	'input_event_visible': 'WAKE_FIXED_EVENT' in rendered}
	requests.append(request)
	print(f' local request {len(requests)} role={role}', flush=True)
	if not child and family == 'completion' and state['parent_count'] == 1:
	print(' spawn result: ' + json.dumps(outputs[-1:]), flush=True)
	base.require(outputs and 'fixed_worker' in json.dumps(outputs[-1]),
	'Spawn failed: ' + json.dumps(outputs[-1:] ))
	base.require(len(requests) < 100, 'Request budget exhausted')
	base.require(request['effort'] == 'low', 'Non-low request')
	base.require(request['model'] == 'gpt-6-astra', 'Unexpected model')
	if child:
	state['child_count'] += 1
	base.require(state['child_count'] == 1, 'Unexpected child loop')
	base.require(started.wait(15), 'Parent never started waiting')
	deadline = state['start_at'] + duration / 1000
	time.sleep(max(0, deadline - time.monotonic()))
	state['event_at'] = time.monotonic()
	item = message('CHILD_FINISHED_FIXED')
	else:
	n = state['parent_count']
	state['parent_count'] += 1
	if family == 'input_event':
	item = (message('PARENT_DONE') if request['input_event_visible'] else
	function('wait_agent', {'timeout_ms':interval}))
	elif family == 'completion':
	if n == 0:
	item = function('spawn_agent', {'task_name': 'fixed_worker',
	'message': 'Fixed-duration local test worker. Return the fixture result.',
	'fork_turns': 'none'})
	elif request['completion_visible']:
	item = message('PARENT_DONE')
	else:
	item = function('wait_agent', {'timeout_ms': interval})
	if not started.is_set():
	state['start_at'] = time.monotonic()
	started.set()
	else:
	if n == 0:
	code = ('// @exec: ' + json.dumps({'yield_time_ms': interval}) + '\n'
	f'await new Promise(resolve => setTimeout(resolve, {duration}));\n'
	'text("WRAPPER_DONE_FIXED");')
	item = {'type': 'custom_tool_call', 'call_id': 'exec-first',
	'name': 'exec', 'namespace': 'functions', 'input': code}
	state['start_at'] = time.monotonic()
	else:
	last = json.dumps(outputs[-1]) if outputs else ''
	match = re.search(r'Script running with cell ID ([^\s"\\]+)', last)
	if match:
	state['cell'] = match.group(1)
	item = function('wait', {'cell_id': state['cell'],
	'yield_time_ms': interval, 'max_tokens': 1000}, 'functions')
	elif 'WRAPPER_DONE_FIXED' in last:
	item = message('PARENT_DONE')
	else:
	raise AssertionError('Unexpected wrapper result: ' + last[:1500])
	identifier = f'fixture-{len(requests)}'
	events = [{'type': 'response.created', 'response': {'id': identifier}},
	{'type': 'response.output_item.done', 'item': item},
	{'type': 'response.completed', 'response': {'id': identifier,
	'usage': {'input_tokens': 0, 'output_tokens': 0, 'total_tokens': 0}}}]
	data = ''.join('data: ' + json.dumps(e) + '\n\n' for e in events).encode()
	self.send_response(200)
	self.send_header('Content-Type', 'text/event-stream')
	self.send_header('Content-Length', str(len(data)))
	self.end_headers()
	self.wfile.write(data)
	except Exception as exc:
	errors.append(str(exc))
	print(' fixture error: ' + str(exc), flush=True)
	self.send_error(500, 'Local fixture failure')

	server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
	server.daemon_threads = True
	threading.Thread(target=server.serve_forever, daemon=True).start()
	try:
	with tempfile.TemporaryDirectory(prefix='controlled-wait-') as folder:
	settings = base.configuration(server.server_port, minimum, 30000, 3600000)
	settings['features.code_mode'] = family == 'wrapper'
	if family == 'input_event':
	command=base.with_config([binary,'app-server'],settings)
	state['start_at'],state['event_at']=fixed_input(command,folder,duration)
	proc=None
	else:
	command = [binary, 'exec', '--ignore-user-config', '--ephemeral',
	'--skip-git-repo-check', '--json', '-s', 'read-only',
	'-m', base.MODEL, '-C', folder]
	base.with_config(command, settings)
	command += ['Controlled local fixture. Run one fixed-duration worker and wait for its result.']
	try:
	if family != 'input_event':
	proc = subprocess.run(command, stdin=subprocess.DEVNULL, capture_output=True,
	text=True, timeout=duration/1000 + 15)
	except subprocess.TimeoutExpired as exc:
	print(' runtime stdout: ' + str(exc.stdout)[-6000:], flush=True)
	print(' runtime stderr: ' + str(exc.stderr)[-2000:], flush=True)
	raise
	base.require(not errors, '; '.join(errors))
	if proc is not None:
	base.require(proc.returncode == 0, proc.stderr[-2000:])
	base.require('PARENT_DONE' in proc.stdout, 'Parent failed to finish')
	finally:
	server.shutdown()
	server.server_close()
	parent = [r for r in requests if r['role'] == 'parent']
	event_latency = None
	if family in ['completion','input_event']:
	if family == 'completion':
	base.require(state['child_count'] == 1, 'Expected exactly one actual child')
	base.require(parent[-1]['completion_visible'], 'Completion missing from parent input')
	else:
	base.require(parent[-1]['input_event_visible'], 'Fixed input missing')
	event_latency = (parent[-1]['at'] - state['event_at']) * 1000
	base.require(0 <= event_latency < 1000, f'Completion latency exceeded bound: {event_latency}')
	# Count outputs from the last logical request once, not repeated transcript copies.
	last_outputs = parent[-1]['outputs']
	timeouts = sum('"timed_out":true' in json.dumps(o).replace(' ', '').replace('\\"', '"')
	for o in last_outputs)
	origin = requests[0]['at']
	for r in requests:
	r['at_ms'] = round((r.pop('at') - origin)*1000, 2)
	r.pop('outputs')
	return {'family': family, 'interval_ms': interval, 'duration_ms': duration,
	'minimum_ms': minimum, 'passed': True, 'parent_requests': len(parent),
	'child_requests': state['child_count'], 'empty_timeouts': timeouts,
	'event_to_parent_request_ms': round(event_latency, 2) if event_latency is not None else None,
	'observed_event_delay_ms': round((state['event_at']-state['start_at'])*1000,2)
	if state['event_at'] is not None else None,
	'parent_input_bytes_sum': sum(r['input_bytes'] for r in parent),
	'last_parent_input_items': parent[-1]['input_items'],
	'requests': requests}


	def main():
	p = argparse.ArgumentParser(description=__doc__)
	p.add_argument('--codex', required=True)
	p.add_argument('--output', type=pathlib.Path, default=pathlib.Path('results.json'))
	p.add_argument('--pilot', action='store_true')
	p.add_argument('--skip-scale', action='store_true')
	args = p.parse_args()
	result = {'pilot': args.pilot, 'upstream_model_requests': 0,
	'version': subprocess.check_output([args.codex, '--version'], text=True).strip(),
	'binary_sha256': hashlib.sha256(pathlib.Path(args.codex).read_bytes()).hexdigest(),
	'runs': [], 'comparisons': []}

	def save():
	args.output.write_text(json.dumps(result, indent=2, ensure_ascii=False)+'\n')

	def one(family, interval, duration=2750, minimum=1):
	print(f'RUN {family} interval={interval} duration={duration}', flush=True)
	try:
	r = run_case(args.codex, family, interval, duration, minimum)
	except Exception as exc:
	r = {'family': family, 'interval_ms': interval, 'duration_ms': duration,
	'passed': False, 'error': str(exc)}
	result['runs'].append(r)
	save()
	raise
	result['runs'].append(r)
	save()
	print(json.dumps({k:v for k,v in r.items() if k != 'requests'}), flush=True)
	return r

	if args.pilot:
	for family in ['input_event', 'wrapper']:
	one(family, 500)
	return
	for family in ['input_event', 'wrapper']:
	for pair, order in enumerate([(500,10000), (10000,500), (500,10000)], 1):
	pair_runs = {interval:one(family,interval) for interval in order}
	a,b = pair_runs[500],pair_runs[10000]
	base.require(a['parent_requests'] > b['parent_requests'], 'No request reduction')
	if family == 'input_event':
	base.require(a['empty_timeouts'] >= 2 and b['empty_timeouts'] == 0,
	'Timeout prediction failed')
	result['comparisons'].append({'family':family,'pair':pair,'passed':True,
	'short_requests':a['parent_requests'],'long_requests':b['parent_requests']})
	save()
	if not args.skip_scale:
	a=one('input_event',30000,65000,10000)
	b=one('input_event',600000,65000,10000)
	base.require(a['empty_timeouts'] >= 2 and b['empty_timeouts'] == 0 and
	a['parent_requests'] > b['parent_requests'], 'Scale prediction failed')
	result['comparisons'].append({'family':'real_scale','passed':True,
	'short_requests':a['parent_requests'],'long_requests':b['parent_requests']})
	save()
	for _ in range(3):
	print('RUN steer_25min', flush=True)
	r=base.mock_case(args.codex, ('steer_25min',[{'timeout_ms':1500000}],1,30000,3600000))
	base.require(r['steer_to_next_request_ms'] < 1000, 'Steer latency exceeded bound')
	# Synthetic usage from this legacy probe is not a measured model cost.
	r.pop('synthetic_usage')
	r['family']='steer'
	result['runs'].append(r)
	save()
	print(json.dumps(r), flush=True)


	if __name__ == '__main__':
	main()