diff --git a/loopx/control_plane/quota/native_context_lifecycle.ts b/loopx/control_plane/quota/native_context_lifecycle.ts index 3d556830cf..a5c505043d 100644 --- a/loopx/control_plane/quota/native_context_lifecycle.ts +++ b/loopx/control_plane/quota/native_context_lifecycle.ts @@ -65,25 +65,37 @@ export function updateNativeContextLifecycle(request: JsonObject): JsonObject { if (same && event.source === "resume" && request.resume_verified === true && !state.pending && candidate?.basis === NATIVE_CONTEXT_BASIS && candidate.capture_bytes_verified === true) return state; - if (same && event.source === "resume" && fileEpochCurrent - && !(candidate?.native_resume || (state.candidate && !candidate))) { - // Resuming a session is not compaction. File comparison does not depend - // on model retention; retire that separate assumption when unverified. - // A previously qualified history checkpoint that now fails can include - // an unreported compaction/rollback, so conservatively rotate below. - delete state.candidate; - delete state.pending; - delete state.active_call; - delete state.section_reads; - // Selected outputs can establish their own literal sections on a - // qualified replay. They never establish a whole-input candidate. + const readScope = jsonObject(state.read_scope); + const selectedResume = jsonObject(state.selected_resume); + const readScopeCurrent = readScope?.session_id === session && readScope.context_epoch === state.context_epoch; + const selectedResumeCurrent = readScopeCurrent && typeof selectedResume?.epoch === "string" + && selectedResume.epoch === state.context_epoch; + if (same && event.source === "resume" && (fileEpochCurrent || selectedResumeCurrent)) { + // A selection has its own replay checkpoint, including after a failed + // full replay leaves the recovery file in the old epoch. const previous = jsonObject(state.consumed_pointers); const replayed = jsonObject(request.resume_sections); const retained = Object.fromEntries(Object.entries(replayed ?? {}).filter(([address, digest]) => typeof digest === "string" && previous?.[address] === digest)); - if (Object.keys(retained).length > 0) { + if (candidate?.native_resume || (state.candidate && !candidate)) { + // Failed complete replay may conceal compaction. Rotate the file + // epoch, keeping only the independently verified literal selections. + invalidate(); + } else { + // Ordinary resume alone is not compaction or proof of model retention. + delete state.candidate; + delete state.pending; + delete state.active_call; + delete state.section_reads; + } + if (readScopeCurrent && Object.keys(retained).length > 0) { + // Only the replay-verified sections move to the new epoch. The next + // projection still matches the rest of the scope and each field's digest. + state.read_scope = {...readScope, context_epoch: state.context_epoch}; state.consumed_pointers = retained; state.confirmed_read_sections = Object.keys(retained); + if (selectedResumeCurrent) + state.selected_resume = {...selectedResume, scope: state.read_scope, epoch: state.context_epoch}; } else { delete state.consumed_pointers; delete state.confirmed_read_sections; diff --git a/loopx/control_plane/turn_driver/codex_context.py b/loopx/control_plane/turn_driver/codex_context.py index a9300f09ab..c776dde3a6 100644 --- a/loopx/control_plane/turn_driver/codex_context.py +++ b/loopx/control_plane/turn_driver/codex_context.py @@ -374,7 +374,7 @@ def codex_context_hook(directory: str | None, event: dict[str, Any]) -> dict[str from ..effect_runtime import EffectRuntimeRemoteError, EffectRuntimeStartupError from .codex_context_history import ( checkpoint_native_read, checkpoint_native_selection, native_resume_sections, native_resume_verified, - observe_native_read, + observe_completed_native_reread, observe_native_read, ) if directory is None: @@ -414,8 +414,9 @@ def codex_context_hook(directory: str | None, event: dict[str, Any]) -> dict[str resume_verified=resume_verified, resume_sections=native_resume_sections(state, event) if name == "SessionStart" and not resume_verified else None) if name == "PostToolUse" and same: - checkpoint_native_read(read_state, updated, event, - [page for page in pages if "read_sections" not in page]) + full_pages = [page for page in pages if "read_sections" not in page] + checkpoint_native_read(read_state, updated, event, full_pages) + observe_completed_native_reread(read_state, updated, event, full_pages) checkpoint_native_selection(state, updated, event, raw_pages, pages) previous = updated.get("host_execution_preparation") ready = previous.get("ready_capture") if isinstance(previous, dict) else None diff --git a/loopx/control_plane/turn_driver/codex_context_history.py b/loopx/control_plane/turn_driver/codex_context_history.py index 212d91eb20..ccaa5cf50f 100644 --- a/loopx/control_plane/turn_driver/codex_context_history.py +++ b/loopx/control_plane/turn_driver/codex_context_history.py @@ -9,13 +9,13 @@ """ from __future__ import annotations +import codecs import hashlib import json import os import re import stat -from collections import Counter -from collections.abc import Iterator +from collections.abc import Iterator, Mapping from contextlib import contextmanager from pathlib import Path from typing import Any, BinaryIO @@ -32,9 +32,27 @@ _IO_CHUNK_BYTES = 64 * 1024 # Bound one decoded protocol record, not the history or the replay interval. _MAX_RECORD_BYTES = 16 * 1024 * 1024 +_MAX_HEADER_FIELD_BYTES = 16 * 1024 +_MAX_PRIMITIVE_BYTES = 1024 +_MAX_SKIP_DEPTH = 256 _MAX_SELECTED_REPLAY_READS = 32 +_MAX_COMPLETE_REREADS = 32 _SHELL_OUTPUT = re.compile(r"\AChunk ID: [^\r\n]+\nWall time: [0-9.]+ seconds\n" r"Process exited with code 0\n(?:Original token count: [0-9]+\n)?Output:\n(.*)\Z", re.DOTALL) +_JSON_WS_STOP = re.compile(rb"[^ \t\r\n]") +_JSON_STR_SPAN = re.compile(rb'(?:[^"\\\x00-\x1f]+|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4})){1,64}') +_JSON_TOKEN_STOP = re.compile(rb"[ \t\r\n,\}\]]") +_PREFIX_PAYLOAD_SPEC: dict[str, Any] = { + "type": None, + "call_id": None, + "name": None, + "turn_id": None, + "item": {"type": None, "id": None, "exit_code": None}, + "internal_chat_message_metadata_passthrough": {"turn_id": None}, +} +_PREFIX_RECORD_SPEC: dict[str, Any] = {"type": None, "payload": _PREFIX_PAYLOAD_SPEC} +_REPLAY_ERRORS = (OSError, ValueError, TypeError, KeyError, AttributeError, RecursionError) +_SOURCE_IDENTITY_FIELDS = ("path", "device", "inode", "metadata_sha256", "model", "permission_mode") def _digest(value: object) -> str: @@ -108,36 +126,323 @@ def _region_digest(stream: BinaryIO, start: int, end: int) -> str: return digest.hexdigest() -def _reader_start(stream: BinaryIO, end: int, pages: list[dict[str, Any]]) -> int: - """Locate this reader at the tail, stopping at its native call boundary. +def _reader_spans(stream: BinaryIO, end: int) -> Iterator[tuple[int, int]]: + """Walk backwards from the hook one bounded chunk at a time, yielding line spans.""" + if end <= 0: + return + stream.seek(end - 1) + if stream.read(1) != b"\n": + raise ValueError("incomplete native reader record") + line_end = end + cursor = end - 1 + while cursor > 0: + chunk_start = max(0, cursor - _IO_CHUNK_BYTES) + stream.seek(chunk_start) + chunk = stream.read(cursor - chunk_start) + if len(chunk) != cursor - chunk_start: + raise ValueError("native reader interval was truncated") + pos = len(chunk) + while True: + split = chunk.rfind(b"\n", 0, pos) + if split < 0: + break + line_start = chunk_start + split + 1 + if line_end > line_start: + yield line_start, line_end + line_end = line_start + pos = split + cursor = chunk_start + if line_end > 0: + yield 0, line_end - A nested code-mode hook may run before the parent output is appended. In - that case the call record anchors the following output, which must exist - and pass complete coverage on resume. Never search the unrelated prefix. - """ - cursor, buffer = end, b"" - while cursor: - start = max(0, cursor - _IO_CHUNK_BYTES) + +def _reject_json_constant(token: str) -> Any: + raise ValueError(f"unsupported JSON constant: {token}") + + +class _JsonSliceCursor: + """Chunked JSON validator and header extractor for oversized Turn-prefix records.""" + + def __init__(self, stream: BinaryIO, start: int, stop: int) -> None: stream.seek(start) - buffer = stream.read(cursor - start) + buffer - cursor = start - while (split := buffer.rstrip(b"\n").rfind(b"\n")) >= 0: - raw, buffer = buffer[split + 1:], buffer[:split + 1] - if len(raw) > _MAX_RECORD_BYTES: + self._stream = stream + self._cursor = start + self._stop = stop + self._buf = b"" + self._pos = 0 + + def _ensure(self, n: int = 1) -> bool: + while len(self._buf) - self._pos < n and self._cursor < self._stop: + chunk = self._stream.read(min(_IO_CHUNK_BYTES, self._stop - self._cursor)) + if not chunk: + raise ValueError("native reader interval was truncated") + self._cursor += len(chunk) + self._buf = self._buf[self._pos:] + chunk + self._pos = 0 + return len(self._buf) - self._pos >= n + + def skip_ws(self) -> int | None: + while True: + if self._pos >= len(self._buf) and not self._ensure(1): + return None + match = _JSON_WS_STOP.search(self._buf, self._pos) + if match is not None: + self._pos = match.start() + return self._buf[self._pos] + self._pos = len(self._buf) + + def consume_byte(self, expected: int) -> None: + if not self._ensure(1) or self._buf[self._pos] != expected: + raise ValueError("malformed native JSON record") + self._pos += 1 + + def scan_string(self, *, capture_limit: int | None = None, allow_long_key: bool = False) -> str: + self.consume_byte(0x22) + decoder = codecs.getincrementaldecoder("utf-8")("strict") + raw: bytearray | None = bytearray(b'"') if capture_limit is not None else None + + def _append_raw(data: bytes) -> bytearray | None: + if raw is None or capture_limit is None: + return None + if len(raw) + len(data) > capture_limit: + if not allow_long_key: + raise ValueError("oversized JSON header field") + return None + raw.extend(data) + return raw + + while True: + if self._pos >= len(self._buf) and not self._ensure(1): + raise ValueError("unterminated JSON string") + match = _JSON_STR_SPAN.match(self._buf, self._pos) + if match is not None: + seg = self._buf[self._pos:match.end()] + decoder.decode(seg, final=False) + raw = _append_raw(seg) + self._pos = match.end() + continue + ch = self._buf[self._pos] + if ch == 0x22: + decoder.decode(b"", final=True) + self._pos += 1 + raw = _append_raw(b'"') + return "" if raw is None else str(json.loads(bytes(raw))) + if ch == 0x5c and len(self._buf) - self._pos < 6 and self._cursor < self._stop: + before = len(self._buf) - self._pos + self._ensure(6) + if len(self._buf) - self._pos > before: + continue + raise ValueError("invalid JSON string") + + def read_primitive(self) -> Any: + raw = bytearray() + while True: + if self._pos >= len(self._buf) and not self._ensure(1): + break + match = _JSON_TOKEN_STOP.search(self._buf, self._pos) + end = len(self._buf) if match is None else match.start() + seg = self._buf[self._pos:end] + if len(raw) + len(seg) > _MAX_PRIMITIVE_BYTES: + raise ValueError("oversized JSON primitive") + raw.extend(seg) + self._pos = end + if match is not None: + break + if not raw: + raise ValueError("expected JSON value") + return json.loads(bytes(raw), parse_constant=_reject_json_constant) + + def skip_value(self) -> None: + stack: list[bool] = [] # True = object, False = array + state = 0 # 0=val, 1=val|arr_end, 2=arr_sep, 3=key|obj_end, 4=key, 5=colon, 6=obj_sep + while True: + ch = self.skip_ws() + if ch is None: + raise ValueError("unexpected EOF in JSON value") + if state in {3, 6}: + if ch == 0x7d: + self._pos += 1 + stack.pop() + if not stack: + return + state = 6 if stack[-1] else 2 + continue + if state == 6: + if ch != 0x2c: + raise ValueError("expected comma or end of JSON object") + self._pos += 1 + state = 4 + continue + state = 4 + if state == 4: + self.scan_string() + state = 5 + continue + if state == 5: + if ch != 0x3a: + raise ValueError("expected colon in JSON object") + self._pos += 1 + state = 0 + continue + if state == 2: + if ch == 0x5d: + self._pos += 1 + stack.pop() + if not stack: + return + state = 6 if stack[-1] else 2 + continue + if ch != 0x2c: + raise ValueError("expected comma or end of JSON array") + self._pos += 1 + state = 0 + continue + if state == 1 and ch == 0x5d: + self._pos += 1 + stack.pop() + if not stack: + return + state = 6 if stack[-1] else 2 + continue + if ch == 0x7b: + if len(stack) >= _MAX_SKIP_DEPTH: + raise RecursionError("JSON nesting too deep") + self._pos += 1 + stack.append(True) + state = 3 + elif ch == 0x5b: + if len(stack) >= _MAX_SKIP_DEPTH: + raise RecursionError("JSON nesting too deep") + self._pos += 1 + stack.append(False) + state = 1 + elif ch == 0x22: + self.scan_string() + if not stack: + return + state = 6 if stack[-1] else 2 + else: + self.read_primitive() + if not stack: + return + state = 6 if stack[-1] else 2 + + def read_small_value(self) -> Any: + ch = self.skip_ws() + if ch is None: + raise ValueError("unexpected EOF in JSON value") + if ch == 0x22: + return self.scan_string(capture_limit=_MAX_HEADER_FIELD_BYTES) + if ch == 0x7b: + self.skip_value() + return {} + if ch == 0x5b: + self.skip_value() + return [] + return self.read_primitive() + + +def _scan_selected_object(cursor: _JsonSliceCursor, spec: Mapping[str, Any]) -> dict[str, Any]: + cursor.consume_byte(0x7b) + result: dict[str, Any] = {} + ch = cursor.skip_ws() + if ch == 0x7d: + cursor._pos += 1 + return result + while True: + if ch != 0x22: + raise ValueError("expected JSON object key") + key = cursor.scan_string(capture_limit=128, allow_long_key=True) + if cursor.skip_ws() != 0x3a: + raise ValueError("expected colon in JSON object") + cursor._pos += 1 + if key not in spec: + cursor.skip_value() + elif isinstance(spec[key], dict): + if cursor.skip_ws() == 0x7b: + result[key] = _scan_selected_object(cursor, spec[key]) + else: + result[key] = cursor.read_small_value() + else: + result[key] = cursor.read_small_value() + ch = cursor.skip_ws() + if ch == 0x7d: + cursor._pos += 1 + return result + if ch != 0x2c: + raise ValueError("expected comma or end of JSON object") + cursor._pos += 1 + ch = cursor.skip_ws() + + +def _scan_turn_prefix_record(stream: BinaryIO, start: int, stop: int) -> dict[str, Any]: + """Decode only Turn/parent metadata from a large earlier record in O(chunk) memory.""" + cursor = _JsonSliceCursor(stream, start, stop) + if cursor.skip_ws() != 0x7b: + raise ValueError("native replay record must be a JSON object") + record = _scan_selected_object(cursor, _PREFIX_RECORD_SPEC) + if cursor.skip_ws() is not None: + raise ValueError("trailing data in native replay record") + return record + + +def _turn_boundary(record: dict[str, Any]) -> bool: + return record.get("type") == "event_msg" and record.get("payload", {}).get("type") == "task_started" + + +def _native_reader(stream: BinaryIO, end: int, event: dict[str, Any]) -> tuple[int, str] | None: + """Bind a hook to its own call, or to a single open native Code Mode call.""" + reader = event["tool_use_id"] + completed = False + closed_parents: set[str] = set() + parent: tuple[int, str] | None = None + for offset, stop in _reader_spans(stream, end): + raw_len = stop - offset - 1 + if parent is None: + if raw_len > _MAX_RECORD_BYTES: raise ValueError("unsupported native reader record") - record = json.loads(raw) - payload = record.get("payload", {}) - offset = cursor + split + 1 - if record.get("type") == "response_item": - if _read_pages(payload.get("output")) == pages: - return offset - if payload.get("type") in {"function_call", "custom_tool_call"}: - return offset - if record.get("type") == "event_msg" and payload.get("type") == "task_started": - return end - if len(buffer) > _MAX_RECORD_BYTES: - raise ValueError("unsupported native reader record") - return end + stream.seek(offset) + record = json.loads(stream.read(stop - offset)) + elif raw_len > _IO_CHUNK_BYTES: + record = _scan_turn_prefix_record(stream, offset, stop - 1) + else: + stream.seek(offset) + record = json.loads(stream.read(stop - offset)) + if _turn_boundary(record): + break + payload = record["payload"] + kind = payload.get("type") + if record.get("type") == "event_msg" and kind == "item_completed": + item = payload.get("item", {}) + if item.get("type") == "CommandExecution" and item.get("id") == reader: + if item.get("exit_code") != 0 or payload.get("turn_id") != event.get("turn_id"): + return None + completed = True + if record.get("type") != "response_item": + continue + call = payload.get("call_id") + if not isinstance(call, str) or not call: + continue + if call == reader and kind in {"function_call", "function_call_output"}: + if raw_len > _MAX_RECORD_BYTES: + return None + if parent is not None and raw_len > _IO_CHUNK_BYTES: + stream.seek(offset) + record = json.loads(stream.read(stop - offset)) + return offset, _digest(record) + if kind == "custom_tool_call_output": + closed_parents.add(call) + if kind != "custom_tool_call" or payload.get("name") != "exec" or call in closed_parents: + continue + if not completed or parent is not None or not isinstance(event.get("turn_id"), str): + return None + # A qualified native record can omit message metadata. The completed + # command still carries the Turn, and the parent is uniquely open. + metadata = payload.get("internal_chat_message_metadata_passthrough") or {} + if metadata.get("turn_id") not in (None, event["turn_id"]): + return None + parent = offset, _digest(record) + return parent def _read_pages(output: object) -> list[dict[str, Any]]: @@ -152,72 +457,145 @@ def _read_pages(output: object) -> list[dict[str, Any]]: return _context_pages(output) -def _matches(anchor: dict[str, Any], snapshot: dict[str, Any], stream: BinaryIO, - event: dict[str, Any], *, selected: bool = False) -> bool: - from .decision_capture import capture_page_range, read_context_capture_file - - if any(anchor.get(k) != snapshot.get(k) for k in - ("path", "device", "inode", "metadata_sha256", "model", "permission_mode")): - return False - start, end = anchor.get("reader_start"), anchor.get("observed_bytes") - if (type(start) is not int or type(end) is not int or not 0 < start <= end <= snapshot["observed_bytes"] - or _region_digest(stream, start, end) != anchor.get("reader_sha256")): - return False - reads, reference = anchor.get("reads"), anchor.get("read_source") - if not isinstance(reads, list) or not reads or not isinstance(reference, dict): - return False - required = {read["call_id"]: read["pages_sha256"] for read in reads} - if len(required) != len(reads): - return False - _, body, _ = read_context_capture_file(reference["path"], reference["sha256"], private=True) - # Verify every observed read, not just EOF. A complete last page must never - # hide an earlier output that the native replay dropped or truncated. - seen: set[str] = set() - expected_pages = Counter(required.values()) - seen_pages: Counter[str] = Counter() - ranges = [] - for _, record in _records(stream, start, snapshot["observed_bytes"]): - payload = record.get("payload", {}) - native_output = payload.get("type") in {"function_call_output", "custom_tool_call_output"} - if record.get("type") == "response_item" and native_output: - call = payload["call_id"] - pages = _read_pages(payload.get("output")) - digest = _digest(pages) - groups = [pages] - if call in required: - if call in seen or digest != required[call]: - return False - seen.add(call) - elif payload.get("type") == "custom_tool_call_output": - output = payload.get("output") - # One native Code Mode parent can retain several emissions - # from independently observed nested reads. Preserve those - # emission boundaries instead of hashing their concatenation - # as if it were one nested read. Every exact group and byte - # still has to be present; duplicate groups do not help. - if isinstance(output, list): - groups = [_read_pages(item.get("text")) for item in output - if isinstance(item, dict) and item.get("type") == "input_text"] - groups = [group for group in groups if group and _digest(group) in expected_pages] - else: - groups = [] - for group in groups: - seen_pages[_digest(group)] += 1 - for page in group: - if selected or page.get("sha256") != reference["sha256"]: - continue - span = capture_page_range(page, raw=body, digest=reference["sha256"]) - if span is None: - return False - ranges.append(span) - if not _append_only(record, event): - return False +def _covers_bytes(ranges: list[tuple[int, int]], total: int) -> bool: cursor = 0 for start, stop in sorted(ranges): if start > cursor: return False cursor = max(cursor, stop) - return seen_pages == expected_pages and (selected or cursor == len(body)) + return cursor == total + + +def _same_replay_source(anchor: dict[str, Any], snapshot: dict[str, Any]) -> bool: + return all(anchor.get(k) == snapshot.get(k) for k in _SOURCE_IDENTITY_FIELDS) + + +def _matching_replay_interval(anchor: dict[str, Any], snapshot: dict[str, Any], stream: BinaryIO) -> bool: + start, end = anchor.get("reader_start"), anchor.get("observed_bytes") + return (_same_replay_source(anchor, snapshot) and type(start) is int and type(end) is int + and 0 < start <= end <= snapshot["observed_bytes"] + and _region_digest(stream, start, end) == anchor.get("reader_sha256")) + + +def _read_receipt(offset: int, digest: str, pages: list[dict[str, Any]]) -> dict[str, Any]: + return {"native_offset": offset, "native_sha256": digest, "pages_sha256": _digest(pages)} + + +def _matching_resume_session(state: dict[str, Any], event: dict[str, Any], anchor: object) -> bool: + return (event.get("source") == "resume" and isinstance(anchor, dict) + and state.get("session_id") == event.get("session_id") + and state.get("cwd") == event.get("cwd")) + + +def _verified_replay_capture(anchor: dict[str, Any], snapshot: dict[str, Any], stream: BinaryIO) -> tuple[Path, bytes, dict[str, Any]] | None: + from .decision_capture import read_context_capture_file + + reference = anchor.get("read_source") + if not isinstance(reference, dict) or not _matching_replay_interval(anchor, snapshot, stream): + return None + return read_context_capture_file(reference["path"], reference["sha256"], private=True) + + +def _emission_pages(payload: dict[str, Any]) -> Iterator[list[dict[str, Any]]]: + output = payload.get("output") + if payload["type"] == "custom_tool_call_output" and isinstance(output, list): + for item in output: + if isinstance(item, dict) and item.get("type") == "input_text": + yield _read_pages(item.get("text")) + else: + yield _read_pages(output) + + +def _replayed_output_groups(anchor: dict[str, Any], snapshot: dict[str, Any], stream: BinaryIO, + event: dict[str, Any], reads: list[dict[str, Any]], + ) -> Iterator[tuple[int, str, list[dict[str, Any]]]]: + # Old private checkpoints did not bind full reads to a call. They may + # still serve their saved file, but cannot attest cross-process retention. + call_offsets: dict[int, str] = {} + for read in reads: + offset, digest = read["native_offset"], read["native_sha256"] + if call_offsets.setdefault(offset, digest) != digest: + raise ValueError("native replay call changed between observations") + native_calls: dict[str, tuple[int, str]] = {} + closed_calls: set[str] = set() + for offset, record in _records(stream, anchor["reader_start"], snapshot["observed_bytes"]): + if not _append_only(record, event): + raise ValueError("unsupported native replay continuation") + payload = record["payload"] + if _turn_boundary(record): + native_calls.clear() + closed_calls.clear() + if record["type"] != "response_item": + continue + kind, call = payload.get("type"), payload.get("call_id") + if kind in {"function_call", "custom_tool_call"}: + # Call IDs can repeat in later Turns. Match the exact call + # occurrence observed by the hook. + native_calls.pop(call, None) + closed_calls.discard(call) + if offset in call_offsets and call_offsets[offset] == _digest(record): + native_calls[call] = offset, kind + elif kind in {"function_call_output", "custom_tool_call_output"}: + opened = native_calls.pop(call, None) + if opened is None: + if call in closed_calls: + raise ValueError("duplicate native tool output without a new call") + if (kind != "function_call_output" or offset not in call_offsets + or call_offsets[offset] != _digest(record)): + continue + call_offset = offset # the direct output was already present at hook time + else: + call_offset, call_kind = opened + if kind != call_kind + "_output" or call_offset not in call_offsets: + continue + closed_calls.add(call) + for group in _emission_pages(payload): + if group: + yield call_offset, _digest(group), group + + +def _matches(anchor: dict[str, Any], snapshot: dict[str, Any], stream: BinaryIO, + event: dict[str, Any]) -> bool: + from .decision_capture import capture_page_range + + reads, rereads = anchor.get("reads"), anchor.get("rereads", []) + if not isinstance(reads, list) or not reads or not isinstance(rereads, list): + return False + verified = _verified_replay_capture(anchor, snapshot, stream) + if verified is None: + return False + _, body, _ = verified + reference_sha = anchor["read_source"]["sha256"] + all_reads = [*reads, *rereads] + required = {(read["native_offset"], read["pages_sha256"]) for read in all_reads} + ranges = [] + for offset, digest, group in _replayed_output_groups(anchor, snapshot, stream, event, all_reads): + if (offset, digest) not in required: + continue + for page in group: + span = capture_page_range(page, raw=body, digest=reference_sha) + if span is None: + return False + ranges.append(span) + # An independently observed reread can recover a missing range. A copy + # emitted by an unrelated call cannot contribute even identical bytes. + return _covers_bytes(ranges, len(body)) + + +def _replayed_selection_sections(anchor: dict[str, Any], snapshot: dict[str, Any], stream: BinaryIO, + event: dict[str, Any]) -> dict[str, str]: + selections = anchor.get("selections") + if not isinstance(selections, dict) or not selections or _verified_replay_capture(anchor, snapshot, stream) is None: + return {} + reads = [read for selection in selections.values() for read in selection["reads"]] + outputs = {(offset, digest) for offset, digest, _ in _replayed_output_groups(anchor, snapshot, stream, event, reads)} + retained = {} + for selection in selections.values(): + ranges = [(read["start"], read["end"]) for read in selection["reads"] + if (read["native_offset"], read["pages_sha256"]) in outputs] + if _covers_bytes(ranges, selection["total_bytes"]): + retained.update(selection["sections"]) + return retained def _append_only(record: dict[str, Any], event: dict[str, Any]) -> bool: @@ -255,53 +633,83 @@ def observe_native_read(state: dict[str, Any], event: dict[str, Any], pending = {} if not isinstance(pending, dict): return state - read = {"call_id": call, "pages_sha256": _digest(pages)} - reads = pending.get("native_reads", []) - if not isinstance(reads, list): - reads = [] + try: + with _snapshot(event) as (facts, stream): + native_reader = _native_reader(stream, facts["observed_bytes"], event) + except _REPLAY_ERRORS: + return state + if native_reader is None: + return state + offset, digest = native_reader + read = _read_receipt(offset, digest, pages) + start, reads = pending.get("native_reader_start"), pending.get("native_reads") + if not isinstance(start, dict) or not isinstance(reads, list) or not _same_replay_source(start, facts): + start, reads = {**facts, "reader_start": offset}, [] + elif offset < start["reader_start"]: + start = {**facts, "reader_start": offset} if read not in reads: reads = [*reads, read] - pending = {**pending, "native_reads": reads} - if "native_reader_start" not in pending: - try: - with _snapshot(event) as (facts, stream): - start = _reader_start(stream, facts["observed_bytes"], pages) - pending["native_reader_start"] = {**facts, "reader_start": start} - except (OSError, ValueError, TypeError, KeyError, AttributeError, RecursionError): - pass + pending = {**pending, "native_reads": reads, "native_reader_start": start} return {**state, "pending": pending} +def observe_completed_native_reread(state: dict[str, Any], updated: dict[str, Any], + event: dict[str, Any], pages: list[dict[str, Any]]) -> None: + """Add independently observed output to the current full-capture checkpoint.""" + candidate = updated.get("candidate") + if not isinstance(candidate, dict) or candidate != state.get("candidate") or not pages: + return + anchor, reference = candidate.get("native_resume"), state.get("recovery") + if (not isinstance(anchor, dict) or not isinstance(reference, dict) + or anchor.get("read_source", {}).get("sha256") != reference.get("sha256") + or any(page.get("ok") is not True or page.get("sha256") != reference.get("sha256") for page in pages)): + return + try: + with _snapshot(event) as (facts, stream): + # Resume checks the original interval digest. Extra observations + # cannot change it and do not need to hash it again at each hook. + if not _same_replay_source(anchor, facts) or anchor["observed_bytes"] > facts["observed_bytes"]: + return + native_reader = _native_reader(stream, facts["observed_bytes"], event) + if native_reader is None or native_reader[0] < anchor["reader_start"]: + return + read = _read_receipt(*native_reader, pages) + rereads = anchor.get("rereads", []) + if read not in anchor["reads"] and read not in rereads: + candidate["native_resume"] = {**anchor, "rereads": [*rereads, read][-_MAX_COMPLETE_REREADS:]} + except _REPLAY_ERRORS: + return + + def native_resume_verified(state: dict[str, Any], event: dict[str, Any]) -> bool: """Observe a qualified replay source; the shared TS owner decides reuse.""" candidate = state.get("candidate") or {} if not isinstance(candidate, dict): return False anchor = candidate.get("native_resume") - if (event.get("source") != "resume" or state.get("pending") or not isinstance(anchor, dict) - or state.get("session_id") != event.get("session_id") or state.get("cwd") != event.get("cwd")): + if not _matching_resume_session(state, event, anchor) or state.get("pending") or not isinstance(anchor, dict): return False try: with _snapshot(event) as (facts, stream): verified = _matches(anchor, facts, stream, event) return verified - except (OSError, ValueError, TypeError, KeyError, AttributeError, RecursionError): + except _REPLAY_ERRORS: return False def native_resume_sections(state: dict[str, Any], event: dict[str, Any]) -> dict[str, str]: """Verify replay of exact selected outputs without claiming a whole capture read.""" anchor = state.get("selected_resume") - if (event.get("source") != "resume" or not isinstance(anchor, dict) - or state.get("session_id") != event.get("session_id") or state.get("cwd") != event.get("cwd") - or anchor.get("scope") != state.get("read_scope") or anchor.get("epoch") != state.get("context_epoch") - or anchor.get("read_source") != state.get("source_recovery") - or not isinstance(anchor.get("sections"), dict)): + if (not _matching_resume_session(state, event, anchor) or not isinstance(anchor, dict) + or anchor.get("scope") != state.get("read_scope") + or anchor.get("epoch") != state.get("context_epoch") + or anchor.get("read_source") != state.get("source_recovery")): return {} try: with _snapshot(event) as (facts, stream): - return anchor["sections"] if _matches(anchor, facts, stream, event, selected=True) else {} - except (OSError, ValueError, TypeError, KeyError, AttributeError, RecursionError): + retained = _replayed_selection_sections(anchor, facts, stream, event) + return retained + except _REPLAY_ERRORS: return {} @@ -317,37 +725,55 @@ def checkpoint_native_selection(state: dict[str, Any], updated: dict[str, Any], consumed = updated.get("consumed_pointers", {}) if (not (raw.get("schema_version") == "context_capture_selection_page_v1" or "selected_pointers" in raw and "selection_sha256" in raw) - or page.get("ok") is not True or page.get("offset") != 0 or page.get("eof") is not True - or page.get("read_sections_inherited") or not isinstance(sections, dict) or not sections + or page.get("ok") is not True or page.get("read_sections_inherited") + or not isinstance(sections, dict) or not isinstance(source, dict) or page.get("source_sha256") != source.get("sha256") or not isinstance(scope, dict) or not epoch or scope.get("context_epoch") != epoch - or not isinstance(call, str) or not call or not isinstance(consumed, dict) - or any(consumed.get(pointer) != digest for pointer, digest in sections.items())): + or not isinstance(call, str) or not call or not isinstance(consumed, dict)): return - receipt = {"call_id": call, "pages_sha256": _digest(raw_pages)} previous = state.get("selected_resume") - if (isinstance(previous, dict) and previous.get("scope") == scope - and previous.get("epoch") == epoch and previous.get("read_source") == source - and all(previous.get(k) == event.get(k) for k in ("model", "permission_mode")) - and previous.get("path") == event.get("transcript_path") - and isinstance(previous.get("reads"), list) and isinstance(previous.get("sections"), dict) - and all(isinstance(read, dict) for read in previous["reads"]) - and len(previous["reads"]) < _MAX_SELECTED_REPLAY_READS): - if any(read.get("call_id") == call for read in previous["reads"]): - return - updated["selected_resume"] = {**previous, "reads": [*previous["reads"], receipt], - "sections": {**previous["sections"], **sections}} - return + same_source = (isinstance(previous, dict) and previous.get("scope") == scope + and previous.get("epoch") == epoch and previous.get("read_source") == source + and previous.get("path") == event.get("transcript_path") + and all(previous.get(k) == event.get(k) for k in ("model", "permission_mode"))) try: with _snapshot(event) as (facts, stream): - end = facts["observed_bytes"] - start = _reader_start(stream, end, raw_pages) - if not 0 < start < end: + native_reader = _native_reader(stream, facts["observed_bytes"], event) + if native_reader is None: + return + native_offset, native_sha256 = native_reader + anchor = previous if isinstance(previous, dict) and same_source and _same_replay_source(previous, facts) else {} + selections = dict(anchor.get("selections", {})) + all_reads = [read for entry in selections.values() for read in entry["reads"]] + if any(read["call_id"] == call and read["native_offset"] == native_offset for read in all_reads): + return + if not selections or len(all_reads) >= _MAX_SELECTED_REPLAY_READS: + end = facts["observed_bytes"] + anchor = {**facts, "reader_start": native_offset, + "reader_sha256": _region_digest(stream, native_offset, end), + "read_source": source, "scope": scope, "epoch": epoch} + selections = {} + if native_offset < anchor["reader_start"]: return - anchor = {**facts, "reader_start": start, "reader_sha256": _region_digest(stream, start, end), - "read_source": source, "reads": [receipt], "sections": sections, "scope": scope, "epoch": epoch} - updated["selected_resume"] = anchor - except (OSError, ValueError, TypeError, KeyError, AttributeError, RecursionError): + # Offsets belong to the exact selected view, which can coincide across + # different sources or presentation bindings. Only combine pages from + # the same physical reader and its verified view. + selection = _digest([raw.get("reference_file") or raw["sha256"], page["sha256"]]) + offset = page["offset"] + end = offset + len(page["content"].encode("utf-8")) + receipt = {"call_id": call, **_read_receipt(native_offset, native_sha256, raw_pages), + "start": offset, "end": end} + entry = selections.get(selection, {}) + observed = entry.get("sections", {}) + progress = [*entry.get("reads", []), receipt] + if _covers_bytes([(read["start"], read["end"]) for read in progress], page["total_bytes"]): + # The reducer and this replay interval both observed full coverage. + # Never resume an inherited selection from only its displayed pages. + if sections and all(consumed.get(pointer) == digest for pointer, digest in sections.items()): + observed = sections + selections[selection] = {"reads": progress, "sections": observed, "total_bytes": page["total_bytes"]} + updated["selected_resume"] = {**anchor, "selections": selections} + except _REPLAY_ERRORS: return @@ -385,5 +811,5 @@ def checkpoint_native_read(state: dict[str, Any], updated: dict[str, Any], "reader_sha256": _region_digest(stream, reader_start, facts["observed_bytes"]), "reads": reads, "read_source": {key: reference[key] for key in ("path", "sha256")}} candidate["native_resume"] = checkpoint - except (OSError, ValueError, TypeError, KeyError, AttributeError, RecursionError): + except _REPLAY_ERRORS: return diff --git a/tests/control_plane/test_codex_context_resume.py b/tests/control_plane/test_codex_context_resume.py index b1027d57ab..75402cb794 100644 --- a/tests/control_plane/test_codex_context_resume.py +++ b/tests/control_plane/test_codex_context_resume.py @@ -1,14 +1,17 @@ """Native replay continuity: completed deliveries, real history changes, fallback.""" from __future__ import annotations +import hashlib import json import os +import shlex import subprocess import sys from pathlib import Path import pytest +from loopx.cli_commands.quota_capture import model_context_reference, native_context_capture_view from loopx.control_plane.quota.turn_envelope import restore_context_delivery from loopx.control_plane.turn_driver import codex_context as context from tests.control_plane.test_codex_context_lifecycle import project, read_pages, setup @@ -42,13 +45,15 @@ def observed_read(root, monkeypatch, *, complete=True, shell_wrapper=False, lost stream.write(b'x' * (1024 * 1024)) stream.write(b'"}}\n') history.chmod(0o600) - event.update(transcript_path=str(history), model="fixture", permission_mode="bypassPermissions") + event.update(transcript_path=str(history), model="fixture", permission_mode="bypassPermissions", + turn_id="read-turn") + append(history, "event_msg", {"type": "task_started", "turn_id": event["turn_id"]}) append(history, "turn_context", {"cwd": str(root), "model": "fixture"}) payload = {"ok": True, "plan_summary": {"requirements": "Keep original evidence. " * 1000}, "heartbeat_receipt": {"turn_instance_id": "first"}} _, first = project(root, payload=payload) pages = read_pages(root, first) - emissions = [] + emissions, parent = [], None for i, page in enumerate(pages if complete else pages[:-1]): call = f"reader-{i}" body = json.dumps(page) @@ -57,13 +62,12 @@ def observed_read(root, monkeypatch, *, complete=True, shell_wrapper=False, lost if code_mode: # Native code-mode retains the parent emission; the nested hook # has a different call id. Its actual output must still cover all bytes. - if parent_batch == 1: - append(history, "response_item", {"type": "custom_tool_call_output", "call_id": f"parent-{i}", - "output": [{"type": "input_text", "text": output}]}) - else: - if not emissions: - append(history, "response_item", {"type": "custom_tool_call", "call_id": f"parent-{i}"}) - emissions.append({"type": "input_text", "text": output}) + if not emissions: + parent = f"parent-{i}" + append(history, "response_item", {"type": "custom_tool_call", "call_id": parent, "name": "exec"}) + append(history, "event_msg", {"type": "item_completed", "turn_id": event["turn_id"], + "item": {"type": "CommandExecution", "id": call, "exit_code": 0}}) + emissions.append({"type": "input_text", "text": output}) else: append(history, "response_item", {"type": "function_call_output", "call_id": call, "output": output}) if lost_prefix and i == len(pages) - 1: @@ -75,7 +79,7 @@ def observed_read(root, monkeypatch, *, complete=True, shell_wrapper=False, lost if emissions and (len(emissions) == parent_batch or i == len(pages) - 1): # Nested read hooks run before the enclosing Code Mode emits its # complete result. Preserve every emission in that native parent. - append(history, "response_item", {"type": "custom_tool_call_output", "call_id": f"parent-{i}", + append(history, "response_item", {"type": "custom_tool_call_output", "call_id": parent, "output": emissions}) emissions = [] return event, history, payload @@ -138,11 +142,14 @@ def test_completed_native_resume_keeps_delta_without_old_capture_prefetch(tmp_pa assert_file_delta(wire, before["recovery"], current) -@pytest.mark.parametrize("replay", ["present", "pinned", "lost_output", "partial", "compacted", "changed_source"]) +@pytest.mark.parametrize("replay", [ + "present", "direct", "pinned", "paged", "out_of_order", "lost_page", "missing_hook", "batched", + "lost_output", "partial", "compacted", "changed_source", + "reread", "reread_lost_page", "reread_changed_page", + "reread_present_unhooked", "reread_lost_unhooked", "reread_lost_verified", +]) def test_native_resume_retains_only_replayed_complete_selections(tmp_path, monkeypatch, replay): """A selected read can survive a qualified replay without proving full input.""" - import hashlib - event = setup(tmp_path, monkeypatch) history = tmp_path / "rollout.jsonl" append(history, "session_meta", {"id": "session", "cwd": str(tmp_path), @@ -150,8 +157,15 @@ def test_native_resume_retains_only_replayed_complete_selections(tmp_path, monke history.chmod(0o600) event.update(transcript_path=str(history), model="fixture", permission_mode="bypassPermissions") append(history, "turn_context", {"cwd": str(tmp_path), "model": "fixture"}) - address = "/requirements" - payload = {"ok": True, "goal_id": "fixture", "requirements": "Preserve the current stop. " * 320, + address = "/interaction_contract/agent_channel/work_context/sources/0/content/text" + narrative = "Preserve the current stop. " * 320 + payload = {"ok": True, "goal_id": "fixture", "selected_todo": {"todo_id": "todo_current"}, + "goal_boundary": {"stop_condition": "Keep the current stop."}, + "interaction_contract": {"schema_version": "loopx_interaction_contract_v0", + "agent_channel": {"work_context": {"sources": [{"source": "goal_state", "content": { + "state_file": "fixture-goal.md", "full_source": True, "text": narrative, + "revision": "sha256:" + hashlib.sha256(narrative.encode()).hexdigest(), + }}]}}, "user_channel": {}, "cli_channel": {}}, "unread": "This is a separate source field. " * 400} _, wire = project(tmp_path, payload=payload) recovery = wire["recovery"] @@ -165,27 +179,92 @@ def command(args, event=None): assert result.returncode == 0, result.stdout + result.stderr return json.loads(result.stdout) - if replay == "pinned": + reread = replay.startswith("reread") + paged = reread or replay in {"paged", "out_of_order", "lost_page", "missing_hook", "batched"} + if paged or replay == "pinned": from loopx.control_plane.turn_driver.decision_capture import write_context_read_reference ref = write_context_read_reference(Path(recovery["path"]), recovery["sha256"]) source = ["--reference-file", str(ref)] else: source = ["--capture-file", recovery["path"], "--capture-sha256", recovery["sha256"]] - page = command(["context-read", *source, "--select", address, "--page-bytes", "1000" if replay == "partial" else "64000", + page = command(["context-read", *source, "--select", address, + "--page-bytes", "3000" if paged or replay == "partial" else "64000", "--max-page-output-bytes", "64000"]) - assert page["ok"] and page["eof"] == (replay != "partial") + assert page["ok"] and page["eof"] == (not paged and replay != "partial") hook = ["context-hook", "--context-delivery", "on", "--codex-app", "--codex-context-dir", str(tmp_path)] - # A code-mode parent may append its actual output after the nested hook. - append(history, "response_item", {"type": "custom_tool_call", "call_id": "parent"}) - command(hook, {**event, "hook_event_name": "PostToolUse", "tool_use_id": "reader", - "tool_response": json.dumps(page)}) + pages = [page] + if paged: + while not pages[-1]["eof"]: + next_command = shlex.split(pages[-1]["next_command"]) + pages.append(command(next_command[next_command.index("context-read"):])) + assert len(pages) > 2 + if replay == "out_of_order": + pages = [pages[-1], *pages[:-1]] + replay_pages = list(pages) + extra_address = "/goal_boundary/stop_condition" + later_turn = {**event, "turn_id": "reread-turn"} + if reread: + extra = command(["context-read", *source, "--select", extra_address]) + assert extra["ok"] and extra["eof"] + replay_pages.insert(0, extra) + emissions = [] + for index, page in enumerate(replay_pages): + # A code-mode parent may append its actual output after the nested hook. + reader = f"reader-{index}" + parent = "parent-batch" if replay == "batched" else f"parent-{index}" + if replay == "direct": + append(history, "response_item", {"type": "function_call", "call_id": reader, "name": "exec_command"}) + elif not emissions: + append(history, "response_item", {"type": "custom_tool_call", "call_id": parent, "name": "exec", + "internal_chat_message_metadata_passthrough": {"turn_id": "initial-turn"}}) + append(history, "event_msg", {"type": "item_completed", + "turn_id": "initial-turn", "item": {"type": "CommandExecution", "id": reader, "exit_code": 0}}) + if replay != "missing_hook" or index != 1: + command(hook, {**event, "turn_id": "initial-turn", "hook_event_name": "PostToolUse", "tool_use_id": reader, + "tool_response": json.dumps(page)}) + missing_page = ((replay == "lost_page" and index == 1) + or (replay == "reread_lost_page" and index == 2) + or (replay in {"reread_lost_unhooked", "reread_lost_verified"} and index == 1)) + if replay != "lost_output" and not missing_page: + retained_page = {**page, "content": page["content"] + " changed"} \ + if replay == "reread_changed_page" and index == 2 else page + if replay == "direct": + append(history, "response_item", {"type": "function_call_output", + "call_id": reader, "output": json.dumps(retained_page)}) + else: + emissions.append({"type": "input_text", "text": json.dumps(retained_page)}) + if emissions and (replay != "batched" or index == len(replay_pages) - 1): + append(history, "response_item", {"type": "custom_tool_call_output", + "call_id": parent, "output": emissions}) + emissions = [] + elif missing_page: + # A complete parent result may omit the nested emission altogether. + append(history, "response_item", {"type": "custom_tool_call_output", + "call_id": parent, "output": []}) + if reread: + again = command(["context-read", *source, "--select", address, "--page-bytes", "3000", + "--max-page-output-bytes", "64000"]) + assert again == pages[0] + append(history, "event_msg", {"type": "task_complete", "turn_id": "initial-turn"}) + append(history, "event_msg", {"type": "task_started", "turn_id": later_turn["turn_id"]}) + # The host may reuse the earlier parent's ID in the next Turn. + parent = "parent-1" + append(history, "response_item", {"type": "custom_tool_call", "call_id": parent, "name": "exec", + "internal_chat_message_metadata_passthrough": {"turn_id": later_turn["turn_id"]}}) + append(history, "event_msg", {"type": "item_completed", + "turn_id": later_turn["turn_id"], + "item": {"type": "CommandExecution", "id": "reader-reread", "exit_code": 0}}) + if not replay.endswith("_unhooked"): + command(hook, {**later_turn, "hook_event_name": "PostToolUse", "tool_use_id": "reader-reread", + "tool_response": json.dumps(again)}) + append(history, "response_item", {"type": "custom_tool_call_output", "call_id": parent, + "output": [{"type": "input_text", "text": json.dumps(again)}]}) before = context._state(tmp_path) - assert (address in before.get("consumed_pointers", {})) == (replay != "partial") + assert (address in before.get("consumed_pointers", {})) == (replay not in {"partial", "missing_hook"}) + if reread: + assert extra_address in before["consumed_pointers"] assert "candidate" not in before - if replay != "lost_output": - append(history, "response_item", {"type": "custom_tool_call_output", "call_id": "parent", - "output": [{"type": "input_text", "text": json.dumps(page)}]}) if replay == "compacted": append(history, "compacted", {"message": "Earlier model context was replaced."}) if replay == "changed_source": @@ -196,8 +275,30 @@ def command(args, event=None): command(hook, {**event, "source": "resume"}) after = context._state(tmp_path) assert "candidate" not in after - expected = {address: before["consumed_pointers"][address]} if replay in {"present", "pinned"} else {} + retained = replay in {"present", "direct", "pinned", "paged", "out_of_order", "batched", + "reread", "reread_present_unhooked", "reread_lost_verified"} + expected = before["consumed_pointers"] if retained else ( + {extra_address: before["consumed_pointers"][extra_address]} if reread else {}) assert after.get("consumed_pointers", {}) == expected + if paged: + delivered_bytes = sum(len(page["content"].encode("utf-8")) for page in pages) + assert delivered_bytes == pages[0]["total_bytes"] > 8_000 + payload["goal_boundary"]["stop_condition"] = "The new stop applies before publication." + directory = tmp_path / "next" + directory.mkdir(mode=0o700) + prepared = context.prepare_codex_context(payload, directory=str(tmp_path), capture_directory=directory, + goal_id="fixture", agent_id="agent", surface="quota_packet", capture_id="next") + view = model_context_reference(native_context_capture_view(prepared.delivery, directory, + context_directory=str(tmp_path), initial_read_plan=prepared.initial_read_plan)) + first_command = shlex.split(view["first_read_command"]) + opening = command(first_command[first_command.index("context-read"):]) + assert opening["eof"] and payload["goal_boundary"]["stop_condition"] in opening["content"] + assert (address in opening.get("previously_delivered_fields", [])) is retained + assert (narrative in opening["content"]) is not retained + if retained: + assert opening["total_bytes"] < len(narrative.encode("utf-8")) + else: + assert opening["total_bytes"] > len(narrative.encode("utf-8")) @pytest.mark.parametrize("single_page", [False, True]) @@ -403,6 +504,135 @@ def test_complete_eof_cannot_hide_a_prior_page_missing_from_native_replay(tmp_pa assert wire["mode"] == "full" and wire["context"] == payload +@pytest.mark.parametrize(("replay", "retained"), [ + ("present", True), ("batch", True), ("missing", False), + ("unobserved_copy", False), ("observed_reread", True), + ("repeated_resume", False), ("repeated_resume_lost_selection", False), +]) +def test_full_capture_resume_requires_the_observed_native_output(tmp_path, monkeypatch, replay, retained): + event = setup(tmp_path, monkeypatch) + history = tmp_path / "rollout.jsonl" + append(history, "session_meta", {"id": "session", "cwd": str(tmp_path), + "cli_version": "0.167.0-alpha.3.2", "history_mode": "paginated"}) + history.chmod(0o600) + turn_id = "capture-turn" + event.update(transcript_path=str(history), model="fixture", permission_mode="bypassPermissions", turn_id=turn_id) + append(history, "event_msg", {"type": "task_started", "turn_id": turn_id}) + append(history, "turn_context", {"cwd": str(tmp_path), "model": "fixture"}) + payload = {"ok": True, "plan_summary": {"requirements": "Keep original evidence. " * 1500}, + "heartbeat_receipt": {"turn_instance_id": "first"}} + repeat_resume = replay in {"repeated_resume", "repeated_resume_lost_selection"} + narrative = "Keep the complete validated Goal narrative. " * 280 + address = "/interaction_contract/agent_channel/work_context/sources/0/content/text" + if repeat_resume: + payload.update(goal_id="fixture", selected_todo={"todo_id": "todo_current"}, + goal_boundary={"stop_condition": "Observe the original stop."}, + interaction_contract={"schema_version": "loopx_interaction_contract_v0", + "agent_channel": {"work_context": {"sources": [{"source": "goal_state", "content": { + "state_file": "fixture-goal.md", "full_source": True, "text": narrative, + "revision": "sha256:" + hashlib.sha256(narrative.encode()).hexdigest(), + }}]}}, "user_channel": {}, "cli_channel": {}}) + _, first = project(tmp_path, payload=payload) + pages = read_pages(tmp_path, first) + assert len(pages) >= 3 and pages[-1]["eof"] + + def open_parent(parent): + append(history, "response_item", {"type": "custom_tool_call", "call_id": parent, "name": "exec", + "internal_chat_message_metadata_passthrough": {"turn_id": turn_id}}) + + def observe(reader, page): + append(history, "event_msg", {"type": "item_completed", "turn_id": turn_id, + "item": {"type": "CommandExecution", "id": reader, "exit_code": 0}}) + context.codex_context_hook(str(tmp_path), {**event, "hook_event_name": "PostToolUse", + "tool_use_id": reader, "tool_response": json.dumps(page)}) + + def emit(parent, contents): + append(history, "response_item", {"type": "custom_tool_call_output", "call_id": parent, + "output": [{"type": "input_text", "text": json.dumps(page)} for page in contents]}) + + def read(*args): + body, wire_bytes, first_page = bytearray(), 0, None + while True: + result = subprocess.run([sys.executable, "-m", "loopx.entrypoint", "--format", "json", "quota", + "context-read", *args], capture_output=True, text=True, timeout=20, check=False) + assert result.returncode == 0, result.stdout + result.stderr + page = json.loads(result.stdout) + assert page["ok"] and page["offset"] == len(body) + first_page = first_page or page + body.extend(page["content"].encode()) + wire_bytes += len(result.stdout.encode()) + if page["eof"]: + assert len(body) == page["total_bytes"] + return first_page, body.decode(), wire_bytes + words = shlex.split(page["next_command"]) + args = words[words.index("context-read") + 1:] + + if repeat_resume: + selected, _, _ = read("--capture-file", first["recovery"]["path"], "--capture-sha256", + first["recovery"]["sha256"], "--select", address, "--page-bytes", "64000", + "--max-page-output-bytes", "64000") + assert selected["eof"] + open_parent("independent-selection") + observe("independent-reader", selected) + emit("independent-selection", [selected]) + if replay == "batch": + open_parent("batch") + for i, page in enumerate(pages): + observe(f"reader-{i}", page) + emit("batch", pages) + else: + for i, page in enumerate(pages): + parent = f"parent-{i}" + open_parent(parent) + observe(f"reader-{i}", page) + emit(parent, [page] if i or replay == "present" else []) + if i == 0 and replay in {"unobserved_copy", "observed_reread"}: + open_parent("copy") + if replay == "observed_reread": + observe("reader-reread", page) + emit("copy", [page]) + before = context._state(tmp_path) + assert before["candidate"]["capture_bytes_verified"] + append(history, "event_msg", {"type": "task_complete", "turn_id": turn_id}) + context.codex_context_hook(str(tmp_path), {**event, "source": "resume"}) + after = context._state(tmp_path) + assert bool(after.get("candidate")) is retained + current = {**payload, "heartbeat_receipt": {"turn_instance_id": "second"}} + if repeat_resume: + assert after.get("consumed_pointers") == {address: before["consumed_pointers"][address]} + assert after["context_epoch"] != before["context_epoch"] + if replay == "repeated_resume_lost_selection": + rows = [json.loads(line) for line in history.read_text().splitlines()] + for row in rows: + if row["type"] == "response_item" and row["payload"].get("type") == "custom_tool_call_output" \ + and row["payload"].get("call_id") == "independent-selection": + row["payload"]["output"] = [] + history.write_text("".join(json.dumps(row) + "\n" for row in rows)) + # An ordinary resume can be repeated before any new capture or tool + # read. Its original native output must still support the selection. + context.codex_context_hook(str(tmp_path), {**event, "source": "resume"}) + assert "candidate" not in context._state(tmp_path) + current["goal_boundary"] = {"stop_condition": "Observe the current stop."} + directory = tmp_path / "second" + directory.mkdir(mode=0o700) + prepared = context.prepare_codex_context(current, directory=str(tmp_path), capture_directory=directory, + goal_id="fixture", agent_id="agent", surface="quota_packet", capture_id="second") + view = native_context_capture_view(prepared.delivery, directory, context_directory=str(tmp_path), + initial_read_plan=prepared.initial_read_plan) + assert view["mode"] == "full" and view["target"]["context_epoch"] == after["context_epoch"] + first_command = shlex.split(model_context_reference(view)["first_read_command"]) + opening, opening_content, _ = read(*first_command[first_command.index("context-read") + 1:]) + assert opening["ok"] and "Observe the current stop." in opening_content + if replay == "repeated_resume": + assert opening["eof"] + assert address in opening.get("previously_delivered_fields", []) and narrative not in opening_content + else: + assert address not in opening.get("previously_delivered_fields", []) and narrative in opening_content + return + _, wire = project(tmp_path, "second", payload=current) + assert wire["mode"] == ("delta" if retained else "full") + + @pytest.mark.parametrize("prefix_mib", [0, 96]) def test_unrelated_history_size_does_not_change_replay_or_decode_cost(tmp_path, monkeypatch, prefix_mib): import tracemalloc @@ -445,3 +675,191 @@ def test_code_mode_retained_emissions_need_complete_native_read_coverage(tmp_pat context.codex_context_hook(str(tmp_path), {**event, "source": "resume"}) _, wire = project(tmp_path, "second", payload=payload) assert wire["mode"] == ("full" if lose_page else "delta") + + +def _write_large_rollout_record(history: Path, kind: str, *, turn_id: str, mib: int = 17) -> None: + chunk = (b'x\\"\\\\\\u0041\xc3\xa9' * 6500)[:65536] # exercises chunk-boundary escapes & UTF-8 + repeat = (mib * 1024 * 1024) // len(chunk) + 1 + if kind == "closed_output": + append(history, "response_item", {"type": "custom_tool_call", "call_id": "earlier-closed", + "name": "exec", "internal_chat_message_metadata_passthrough": {"turn_id": turn_id}}) + with history.open("ab") as stream: + stream.write(b'{"type":"response_item","payload":{"output":[{"type":"input_text","text":"') + for _ in range(repeat): + stream.write(chunk) + stream.write(b'"}],"call_id":"earlier-closed","type":"custom_tool_call_output"}}\n') + else: + with history.open("ab") as stream: + stream.write(b'{"type":"event_msg","payload":{"message":"') + for _ in range(repeat): + stream.write(chunk) + stream.write(b'","type":"background_event"}}\n') + + +@pytest.mark.parametrize("same_turn", [False, True]) +@pytest.mark.parametrize("code_mode", [False, True]) +@pytest.mark.parametrize("record_kind", ["background_event", "closed_output"]) +def test_same_turn_large_earlier_record_preserves_native_full_resume(tmp_path, monkeypatch, same_turn, code_mode, record_kind): + import tracemalloc + + event = setup(tmp_path, monkeypatch) + history = tmp_path / "rollout.jsonl" + append(history, "session_meta", {"id": "session", "cwd": str(tmp_path), + "cli_version": "0.167.0-alpha.3.2", "history_mode": "paginated"}) + if not same_turn: + append(history, "event_msg", {"type": "task_started", "turn_id": "prior-turn"}) + _write_large_rollout_record(history, record_kind, turn_id="prior-turn") + append(history, "event_msg", {"type": "task_complete", "turn_id": "prior-turn"}) + turn_id = "current-turn" + append(history, "event_msg", {"type": "task_started", "turn_id": turn_id}) + append(history, "turn_context", {"cwd": str(tmp_path), "model": "fixture"}) + if same_turn: + _write_large_rollout_record(history, record_kind, turn_id=turn_id) + history.chmod(0o600) + event.update(transcript_path=str(history), model="fixture", permission_mode="bypassPermissions", turn_id=turn_id) + payload = {"ok": True, "plan_summary": {"requirements": "Keep original evidence. " * 1400}, + "heartbeat_receipt": {"turn_instance_id": "first"}} + _, first = project(tmp_path, payload=payload) + pages = read_pages(tmp_path, first, size=2048) + assert len(pages) >= 15 and pages[-1]["eof"] + peak = 0 + for i, page in enumerate(pages): + call = f"reader-{i}" + body = json.dumps(page) + if code_mode: + parent = f"parent-{i}" + append(history, "response_item", {"type": "custom_tool_call", "call_id": parent, "name": "exec", + "internal_chat_message_metadata_passthrough": {"turn_id": turn_id}}) + append(history, "event_msg", {"type": "item_completed", "turn_id": turn_id, + "item": {"type": "CommandExecution", "id": call, "exit_code": 0}}) + else: + append(history, "response_item", {"type": "function_call_output", "call_id": call, "output": body}) + if i == 0: + tracemalloc.start() + try: + context.codex_context_hook(str(tmp_path), {**event, "hook_event_name": "PostToolUse", + "tool_use_id": call, "tool_response": body}) + _, hook_peak = tracemalloc.get_traced_memory() + peak = max(peak, hook_peak) + finally: + tracemalloc.stop() + else: + context.codex_context_hook(str(tmp_path), {**event, "hook_event_name": "PostToolUse", + "tool_use_id": call, "tool_response": body}) + if code_mode: + append(history, "response_item", {"type": "custom_tool_call_output", "call_id": parent, + "output": [{"type": "input_text", "text": body}]}) + assert peak < 2 * 1024 * 1024 + before = context._state(tmp_path) + assert before["candidate"]["native_resume"]["reads"] + append(history, "event_msg", {"type": "task_complete", "turn_id": turn_id}) + context.codex_context_hook(str(tmp_path), {**event, "source": "resume"}) + assert "candidate" in context._state(tmp_path) + _, wire = project(tmp_path, "second", payload={**payload, "heartbeat_receipt": {"turn_instance_id": "second"}}) + assert wire["mode"] == "delta" and wire["continuity_basis"] == "captured_file" + + +@pytest.mark.parametrize("same_turn", [False, True]) +@pytest.mark.parametrize("code_mode", [False, True]) +def test_same_turn_large_earlier_record_preserves_native_selected_resume(tmp_path, monkeypatch, same_turn, code_mode): + from argparse import Namespace + + from loopx.cli_commands.quota_capture import read_context_capture + + event = setup(tmp_path, monkeypatch) + history = tmp_path / "rollout.jsonl" + append(history, "session_meta", {"id": "session", "cwd": str(tmp_path), + "cli_version": "0.167.0-alpha.3.2", "history_mode": "paginated"}) + if not same_turn: + append(history, "event_msg", {"type": "task_started", "turn_id": "prior-turn"}) + _write_large_rollout_record(history, "background_event", turn_id="prior-turn") + append(history, "event_msg", {"type": "task_complete", "turn_id": "prior-turn"}) + turn_id = "selection-turn" + append(history, "event_msg", {"type": "task_started", "turn_id": turn_id}) + append(history, "turn_context", {"cwd": str(tmp_path), "model": "fixture"}) + if same_turn: + _write_large_rollout_record(history, "background_event", turn_id=turn_id) + history.chmod(0o600) + event.update(transcript_path=str(history), model="fixture", permission_mode="bypassPermissions", turn_id=turn_id) + address = "/interaction_contract/agent_channel/work_context/sources/0/content/text" + narrative = "Preserve selection across large same-turn records. " * 280 + payload = {"ok": True, "goal_id": "fixture", "selected_todo": {"todo_id": "todo_current"}, + "goal_boundary": {"stop_condition": "Current boundary."}, + "interaction_contract": {"schema_version": "loopx_interaction_contract_v0", + "agent_channel": {"work_context": {"sources": [{"source": "goal_state", "content": { + "state_file": "fixture-goal.md", "full_source": True, "text": narrative, + "revision": "sha256:" + hashlib.sha256(narrative.encode()).hexdigest(), + }}]}}, "user_channel": {}, "cli_channel": {}}} + _, first = project(tmp_path, payload=payload) + selected = read_context_capture(Namespace(capture_file=first["recovery"]["path"], + capture_sha256=first["recovery"]["sha256"], select=[address], offset=0, + page_bytes=64000, max_page_output_bytes=64000, format="json")) + assert selected["ok"] and selected["eof"] + body = json.dumps(selected) + if code_mode: + append(history, "response_item", {"type": "custom_tool_call", "call_id": "parent-sel", "name": "exec", + "internal_chat_message_metadata_passthrough": {"turn_id": turn_id}}) + append(history, "event_msg", {"type": "item_completed", "turn_id": turn_id, + "item": {"type": "CommandExecution", "id": "reader-sel", "exit_code": 0}}) + else: + append(history, "response_item", {"type": "function_call", "call_id": "reader-sel", "name": "exec_command"}) + append(history, "response_item", {"type": "function_call_output", "call_id": "reader-sel", "output": body}) + context.codex_context_hook(str(tmp_path), {**event, "hook_event_name": "PostToolUse", + "tool_use_id": "reader-sel", "tool_response": body}) + if code_mode: + append(history, "response_item", {"type": "custom_tool_call_output", "call_id": "parent-sel", + "output": [{"type": "input_text", "text": body}]}) + assert "selected_resume" in context._state(tmp_path) + context.codex_context_hook(str(tmp_path), {**event, "source": "resume"}) + after = context._state(tmp_path) + assert address in after.get("consumed_pointers", {}) + directory = tmp_path / "next" + directory.mkdir(mode=0o700) + prepared = context.prepare_codex_context(payload, directory=str(tmp_path), capture_directory=directory, + goal_id="fixture", agent_id="agent", surface="quota_packet", capture_id="next") + view = model_context_reference(native_context_capture_view(prepared.delivery, directory, + context_directory=str(tmp_path), initial_read_plan=prepared.initial_read_plan)) + first_args = shlex.split(view["first_read_command"]) + ref_file = first_args[first_args.index("--reference-file") + 1] + opening = read_context_capture(Namespace(reference_file=ref_file, offset=0, + page_bytes=12000, max_page_output_bytes=12000, format="json")) + assert opening["ok"] and address in opening.get("previously_delivered_fields", []) + assert narrative not in opening["content"] + + +@pytest.mark.parametrize("failure_mode", ["ambiguous_open_parent", "malformed_large_record"]) +def test_same_turn_large_earlier_record_keeps_ambiguity_and_corruption_rejected(tmp_path, monkeypatch, failure_mode): + event = setup(tmp_path, monkeypatch) + history = tmp_path / "rollout.jsonl" + append(history, "session_meta", {"id": "session", "cwd": str(tmp_path), + "cli_version": "0.167.0-alpha.3.2", "history_mode": "paginated"}) + turn_id = "negative-turn" + append(history, "event_msg", {"type": "task_started", "turn_id": turn_id}) + append(history, "turn_context", {"cwd": str(tmp_path), "model": "fixture"}) + if failure_mode == "ambiguous_open_parent": + append(history, "response_item", {"type": "custom_tool_call", "call_id": "earlier-still-open", + "name": "exec", "internal_chat_message_metadata_passthrough": {"turn_id": turn_id}}) + _write_large_rollout_record(history, "background_event", turn_id=turn_id) + else: + with history.open("ab") as stream: + stream.write(b'{"type":"event_msg","payload":{"message":"' + b"x" * (17 * 1024 * 1024) + b'\x01"}}\n') + history.chmod(0o600) + event.update(transcript_path=str(history), model="fixture", permission_mode="bypassPermissions", turn_id=turn_id) + payload = {"ok": True, "plan_summary": {"requirements": "Keep original evidence. " * 1000}} + _, first = project(tmp_path, payload=payload) + pages = read_pages(tmp_path, first) + for i, page in enumerate(pages): + body = json.dumps(page) + parent = f"current-open-{i}" + call = f"reader-{i}" + append(history, "response_item", {"type": "custom_tool_call", "call_id": parent, "name": "exec", + "internal_chat_message_metadata_passthrough": {"turn_id": turn_id}}) + append(history, "event_msg", {"type": "item_completed", "turn_id": turn_id, + "item": {"type": "CommandExecution", "id": call, "exit_code": 0}}) + context.codex_context_hook(str(tmp_path), {**event, "hook_event_name": "PostToolUse", + "tool_use_id": call, "tool_response": body}) + append(history, "response_item", {"type": "custom_tool_call_output", "call_id": parent, + "output": [{"type": "input_text", "text": body}]}) + assert "native_resume" not in context._state(tmp_path)["candidate"] + context.codex_context_hook(str(tmp_path), {**event, "source": "resume"}) + assert "candidate" not in context._state(tmp_path) diff --git a/tests/control_plane_ts/context_delivery.test.ts b/tests/control_plane_ts/context_delivery.test.ts index 8e560c25c2..ae2da35865 100644 --- a/tests/control_plane_ts/context_delivery.test.ts +++ b/tests/control_plane_ts/context_delivery.test.ts @@ -5,7 +5,7 @@ import type {JsonObject} from "../../loopx/control_plane/effect_program.ts"; import {compactTodoContextSource, prepareContextDelivery, restoreContextDelivery} from "../../loopx/control_plane/quota/context_delivery.ts"; import {evaluateTurnEnvelope} from "../../loopx/control_plane/quota/turn_envelope.ts"; -import {updateNativeContextLifecycle} from "../../loopx/control_plane/quota/native_context_lifecycle.ts"; +import {NATIVE_CONTEXT_BASIS, updateNativeContextLifecycle} from "../../loopx/control_plane/quota/native_context_lifecycle.ts"; test("only the provider-qualified native replay can retain a complete resume baseline", () => { const state = {session_id: "native", cwd: "/workspace", context_epoch: "original", @@ -1010,3 +1010,37 @@ test("file delta recovery preserves inherited numeric leaves across sibling edit assert.equal(restored.mode, "delta"); assert.deepEqual(restored.context, current); }); + +test("selected-scope replay survives candidate invalidation and rotates into the new epoch", () => { + const scope = {session_id: "native", context_epoch: "epoch-1"}; + const state = { + session_id: "native", + cwd: "/workspace", + context_epoch: "epoch-1", + read_scope: scope, + candidate: {basis: NATIVE_CONTEXT_BASIS, capture_bytes_verified: true, native_resume: {reader_start: 100}}, + consumed_pointers: {"/a": "sha256:aaa", "/b": "sha256:bbb"}, + confirmed_read_sections: ["/a", "/b"], + selected_resume: {scope, epoch: "epoch-1", selections: {}}, + }; + const event = {hook_event_name: "SessionStart", source: "resume", session_id: "native", cwd: "/workspace"}; + const rotated = updateNativeContextLifecycle({ + state, event, new_epoch: "epoch-2", resume_verified: false, + resume_sections: {"/a": "sha256:aaa", "/b": "sha256:stale"}, + }); + assert.equal(rotated.context_epoch, "epoch-2"); + assert.equal(rotated.candidate, undefined); + assert.deepEqual(rotated.read_scope, {session_id: "native", context_epoch: "epoch-2"}); + assert.deepEqual(rotated.consumed_pointers, {"/a": "sha256:aaa"}); + assert.deepEqual(rotated.confirmed_read_sections, ["/a"]); + assert.deepEqual((rotated.selected_resume as JsonObject).epoch, "epoch-2"); + assert.deepEqual((rotated.selected_resume as JsonObject).scope, rotated.read_scope); + + const cleared = updateNativeContextLifecycle({ + state: rotated, event, new_epoch: "epoch-3", resume_verified: false, resume_sections: {}, + }); + assert.equal(cleared.context_epoch, "epoch-2"); + assert.equal(cleared.consumed_pointers, undefined); + assert.equal(cleared.confirmed_read_sections, undefined); + assert.equal(cleared.selected_resume, undefined); +});