第 3 周：上下文快满了，Codex 怎么办？

const APPROX_BYTES_PER_TOKEN: usize = 4;
// ...
pub fn approx_token_count(text: &str) -> usize {
    let len = text.len();
    len.saturating_add(APPROX_BYTES_PER_TOKEN.saturating_sub(1)) / APPROX_BYTES_PER_TOKEN
}

pub fn resolved_context_window(&self) -> Option<i64> {
    self.context_window.or(self.max_context_window)
}

/// Context available to inference after reserving this model's configured headroom.
pub fn usable_context_window(&self) -> Option<i64> {
    self.resolved_context_window().map(|context_window| {
        context_window.saturating_mul(self.effective_context_window_percent) / 100
    })
}

pub fn auto_compact_token_limit(&self) -> Option<i64> {
    let context_limit = self
        .resolved_context_window()
        .map(|context_window| (context_window * 9) / 10);
    let config_limit = self.auto_compact_token_limit;
    if let Some(context_limit) = context_limit {
        return Some(
            config_limit.map_or(context_limit, |limit| std::cmp::min(limit, context_limit)),
        );
    }
    config_limit
}

let full_context_window_limit = model_info.resolved_context_window().map(|context_window| {
    context_window.saturating_mul(model_info.effective_context_window_percent) / 100
});
// ...
let full_context_window_limit_reached =
    full_context_window_limit.is_some_and(|limit| active_context_tokens >= limit);
let token_limit_reached = buffered_auto_compact_limit
    .is_some_and(|limit| auto_compact_scope_tokens >= limit)
    || full_context_window_limit_reached;

let should_roll_over = needs_follow_up
    && (sess.take_new_context_window_request().await || token_limit_reached);
// ...
// as long as compaction works well in getting us way below the token limit, we shouldn't worry about being in an infinite loop.
if should_roll_over {
    if let Err(err) = run_auto_compact(
        // ...
        InitialContextInjection::BeforeLastUserMessage { /* ... */ },
        CompactionReason::ContextLimit,
        CompactionPhase::MidTurn,
    )
    .await
    { /* 压缩失败：报错，结束这个 turn */ }
    // ...
    continue;
}

You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.

Include:
- Current progress and key decisions made
- Important context, constraints, or user preferences
- What remains to be done (clear next steps)
- Any critical data, examples, or references needed to continue

Be concise, structured, and focused on helping the next LLM seamlessly continue the work.

Another language model started to solve this problem and produced a summary of its thinking process. You also have access to the state of the tools that were used by that language model. Use this to build on the work that has already been done and avoid duplicating work. Here is the summary produced by the other language model, use the information in this summary to assist with your own analysis:

let mut remaining = max_tokens;                       // 20_000
for message in user_messages.iter().rev() {           // 从最新的用户消息往回
    if remaining == 0 { break; }
    let tokens = approx_token_count(&message.message); // 4 字节 ≈ 1 token
    // ...
    let content = if tokens <= remaining /* 且全是文本 */ {
        content.clone()                                // 放得下：原样保留
    } else {
        vec![ContentItem::InputText {
            text: truncate_text(&message.message, TruncationPolicy::Tokens(remaining)),
        }]                                             // 放不下：保留头尾、截掉中间，总量≈剩余额度（带 tokens truncated 标记）
    };
    selected_messages.push(/* ... */);
    if tokens > remaining { break; }                   // 截过一条就停
    remaining = remaining.saturating_sub(tokens);
}
selected_messages.reverse();                           // 恢复时间顺序
// ...
history.push(/* CompactionSummary：SUMMARY_PREFIX + 摘要，role 是 user */);

Err(e) if matches!(e.details(), CodexErrorDetails::ContextWindowExceeded) => {
    if turn_input_len > 1 {
        // Trim from the beginning to preserve cache (prefix-based) and keep recent messages intact.
        error!(
            "Context window exceeded while compacting; removing oldest history item. Error: {e}"
        );
        history.remove_first_item();
        retries = 0;
        continue;
    }
    sess.set_total_tokens_full(turn_context.as_ref()).await;
    return Err(e);
}

if let Some(checkpoint) = history_checkpoint
    && let Some(items) = &checkpoint.compacted.replacement_history
{
    history.replace_annotated(items.clone());          // 基底 = 压缩后的完整历史
    // ...
}
let rollout_suffix =
    history_checkpoint.map_or(rollout_items, |checkpoint| checkpoint.suffix);
for item in rollout_suffix {                           // 只重放检查点之后的条目
    match item {
        RolloutItem::ResponseItem(response_item) => { history.replay_annotated_item(/* ... */); }
        RolloutItem::EventMsg(EventMsg::ThreadRolledBack(rollback)) => {
            history.drop_last_n_user_turns(rollback.num_turns);
        }
        // ...
    }
}

"""只读统计 Codex 会话记录（rollout JSONL）：条目类型、事件子类型、压缩事件。

不打印任何对话内容，只输出类型名和数字。不修改任何文件。

用法：
  python3 rollout_stats.py              # 扫 $CODEX_HOME/sessions（默认 ~/.codex/sessions）
  python3 rollout_stats.py 某个目录      # 扫指定目录
  python3 rollout_stats.py --demo       # 本机没有数据时：按源码里的格式造一个样例文件再统计

格式依据（openai/codex@7993248）：
  每行一个 RolloutLine：{"timestamp", "ordinal"?, "type", "payload"}（history/src/lib.rs:361-367）
  type 取值见 RolloutItemWire（history/src/rollout_payload.rs:30-72）
"""
import json
import os
import statistics
import sys
import tempfile
from collections import Counter
from pathlib import Path


def sessions_dir() -> Path:
    home = os.environ.get("CODEX_HOME")
    return (Path(home) if home else Path.home() / ".codex") / "sessions"


def token_total(payload: dict):
    """token_count 事件里最近一次请求的 total_tokens；没有就返回 None。"""
    info = payload.get("info") or {}
    last = info.get("last_token_usage") or {}
    return last.get("total_tokens"), info.get("model_context_window")


def scan_file(path: Path, st: dict) -> None:
    last_tokens = None      # 压缩前最近一次 token_count
    waiting = False         # 刚遇到 compacted，等它后面的第一个 token_count
    before = None           # 这个检查点之前最近一次 token_count（可能没有）
    had_compaction = False
    with path.open(encoding="utf-8", errors="replace") as f:
        for raw in f:
            st["lines"] += 1
            try:
                line = json.loads(raw)
            except json.JSONDecodeError:
                st["bad_lines"] += 1    # 正在写入的会话，最后一行可能还不完整
                continue
            kind = line.get("type")
            payload = line.get("payload") or {}
            st["types"][kind] += 1
            if kind == "event_msg":
                st["events"][payload.get("type")] += 1
                if payload.get("type") == "token_count":
                    total, window = token_total(payload)
                    if total is not None:
                        st["windows"][window] += 1
                        if waiting:
                            st["pairs"].append((before, total))
                            waiting = False
                        last_tokens = total
            elif kind == "response_item":
                st["items"][payload.get("type")] += 1
            elif kind == "compacted":
                had_compaction = True
                history = payload.get("replacement_history") or []
                st["replacement_len"].append(len(history))
                # 远程压缩的摘要是加密的 compaction 条目，message 为空；本地压缩 message 是摘要原文
                st["remote_like"] += 1 if not payload.get("message") else 0
                for item in history:
                    st["kept"][f'{item.get("type")}/{item.get("role", "-")}'] += 1
                waiting, before = True, last_tokens
    st["files"] += 1
    st["files_with_compaction"] += had_compaction


def report(root: Path) -> None:
    st = {
        "files": 0, "lines": 0, "bad_lines": 0, "files_with_compaction": 0, "remote_like": 0,
        "types": Counter(), "events": Counter(), "items": Counter(), "windows": Counter(),
        "kept": Counter(), "replacement_len": [], "pairs": [],
    }
    for path in sorted(root.rglob("rollout-*.jsonl")):
        scan_file(path, st)
    if st["files"] == 0:
        print(f"{root} 下没有 rollout-*.jsonl。可以加 --demo 用样例数据跑一遍。")
        return

    print(f"文件 {st['files']} 个，{st['lines']:,} 行，解析失败 {st['bad_lines']} 行")
    print("\n[顶层 type]")
    for k, v in st["types"].most_common():
        print(f"  {k:<36}{v:>8,}")
    print("\n[event_msg 子类型，前 8]")
    for k, v in st["events"].most_common(8):
        print(f"  {k:<36}{v:>8,}")
    print("\n[response_item 子类型]")
    for k, v in st["items"].most_common():
        print(f"  {k:<36}{v:>8,}")
    print("\n[token_count 里的 model_context_window]")
    for k, v in st["windows"].most_common(5):
        print(f"  {k!s:<36}{v:>8,}")

    n = len(st["replacement_len"])
    print(f"\n[压缩检查点] {n} 个，分布在 {st['files_with_compaction']} 个文件；"
          f"message 为空（摘要加密、疑似远程压缩）{st['remote_like']} 个")
    if n:
        print(f"  replacement_history 条数：中位数 {statistics.median(st['replacement_len'])}，"
              f"最少 {min(st['replacement_len'])}，最多 {max(st['replacement_len'])}")
        print("  replacement_history 里保留了什么（type/role）：")
        for k, v in st["kept"].most_common():
            print(f"    {k:<34}{v:>6,}")
    no_before = sum(1 for b, _ in st["pairs"] if b is None)
    with_before = [(b, a) for b, a in st["pairs"] if b is not None]
    dropped = [(b, a) for b, a in with_before if a < b]
    flat = sum(1 for b, a in with_before if a == b)
    rose = sum(1 for b, a in with_before if a > b)
    print(f"  后面跟着 token_count 的 {len(st['pairs'])} 个：下降 {len(dropped)}，持平 {flat}，"
          f"上升 {rose}，之前没有 token_count {no_before}")
    if dropped:
        ratios = [a / b for b, a in dropped]
        print(f"  下降的那些：压缩前中位数 {statistics.median(b for b, _ in dropped):,.0f}，"
              f"压缩后中位数 {statistics.median(a for _, a in dropped):,.0f}，"
              f"压缩后 / 压缩前 中位数 {statistics.median(ratios):.1%}")


def write_demo(directory: Path) -> None:
    """按源码里的格式造一个最小样例：两轮对话，中间发生一次本地压缩。内容都是虚构的。"""
    ts = "2026-10-01T10:00:00.000Z"

    def msg(role, text):
        kind = "input_text" if role == "user" else "output_text"
        return {"type": "message", "role": role, "content": [{"type": kind, "text": text}]}

    def usage(total, window=258_400):
        last = {"input_tokens": total - 200, "cached_input_tokens": 0, "cache_write_input_tokens": 0,
                "output_tokens": 200, "reasoning_output_tokens": 0, "total_tokens": total}
        return {"type": "token_count", "rate_limits": None,
                "info": {"total_token_usage": last, "last_token_usage": last, "model_context_window": window}}

    prefix = ("Another language model started to solve this problem and produced a summary of its thinking "
              "process. ...")  # SUMMARY_PREFIX 的开头，原文见 prompts/templates/compact/summary_prefix.md
    rows = [
        ("session_meta", {"id": "demo-thread", "timestamp": ts, "cwd": "/demo", "originator": "demo",
                          "cli_version": "0.0.0", "source": "cli", "model_provider": "demo"}),
        ("event_msg", {"type": "task_started", "turn_id": "t1"}),
        ("turn_context", {"turn_id": "t1", "cwd": "/demo", "model": "demo-model"}),
        ("response_item", msg("user", "（虚构）修一下登录页的 bug，不要改公开 API")),
        ("response_item", {"type": "function_call", "name": "shell", "arguments": "{}", "call_id": "c1"}),
        ("response_item", {"type": "function_call_output", "call_id": "c1", "output": "（虚构）很长的日志 ..."}),
        ("event_msg", usage(246_000)),   # 超过 272,000 × 90% = 244,800
        ("compacted", {"message": prefix + "\n（虚构）摘要：已定位到 lockout.py ...",
                       "replacement_history": [msg("user", "（虚构）修一下登录页的 bug，不要改公开 API"),
                                               msg("user", prefix + "\n（虚构）摘要 ...")],
                       "window_number": 1}),
        ("event_msg", usage(3_100)),
        ("response_item", msg("assistant", "（虚构）已修复")),
        ("event_msg", {"type": "task_complete", "turn_id": "t1"}),
    ]
    path = directory / "2026" / "10" / "01" / "rollout-2026-10-01T10-00-00-demo-thread.jsonl"
    path.parent.mkdir(parents=True)
    with path.open("w", encoding="utf-8") as f:
        for i, (kind, payload) in enumerate(rows):
            f.write(json.dumps({"timestamp": ts, "ordinal": i, "type": kind, "payload": payload},
                               ensure_ascii=False) + "\n")


def main() -> None:
    args = sys.argv[1:]
    if args == ["--demo"]:
        with tempfile.TemporaryDirectory() as tmp:
            write_demo(Path(tmp))
            print("（样例数据，按源码格式虚构）")
            report(Path(tmp))
        return
    report(Path(args[0]).expanduser() if args else sessions_dir())


if __name__ == "__main__":
    main()

$ python3 rollout_stats.py
文件 277 个，138,118 行，解析失败 0 行

[顶层 type]
  response_item                         63,729
  event_msg                             57,979
  token_usage_record                    10,852
  turn_context                           3,148
  inter_agent_communication_metadata     1,106
  world_state                              880
  session_meta                             387
  compacted                                 37

[event_msg 子类型，前 8]
  item_completed                        34,022
  token_count                           21,153
  task_started                           1,279
  task_complete                          1,030
  thread_settings_applied                  355
  turn_aborted                             104
  thread_goal_updated                       36

[token_count 里的 model_context_window]
  828400                                11,383
  258400                                 5,769
  251750                                 2,090
  353400                                 1,839
  950000                                    32

[压缩检查点] 37 个，分布在 22 个文件；message 为空（摘要加密、疑似远程压缩）24 个
  replacement_history 条数：中位数 21，最少 5，最多 67
  replacement_history 里保留了什么（type/role）：
    message/user                         874
    message/developer                     83
    message/assistant                     47
    compaction/-                          24
  后面跟着 token_count 的 37 个：下降 22，持平 11，上升 0，之前没有 token_count 4
  下降的那些：压缩前中位数 223,871，压缩后中位数 22,058，压缩后 / 压缩前 中位数 6.1%

$ python3 rollout_stats.py --demo
（样例数据，按源码格式虚构）
文件 1 个，11 行，解析失败 0 行
...
[压缩检查点] 1 个，分布在 1 个文件；message 为空（摘要加密、疑似远程压缩）0 个
  replacement_history 条数：中位数 2，最少 2，最多 2
  replacement_history 里保留了什么（type/role）：
    message/user                           2
  后面跟着 token_count 的 1 个：下降 1，持平 0，上升 0，之前没有 token_count 0
  下降的那些：压缩前中位数 246,000，压缩后中位数 3,100，压缩后 / 压缩前 中位数 1.3%