Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust
153 KB
Raw Blame
from __future__ import annotations

import asyncio
import json
import os
import queue
import signal
import subprocess
import sys
import tempfile
import threading
import time
import unittest
from unittest import mock

SRC = os.path.join(os.path.dirname(__file__), "..", "src")

_EOF = object()


class ReplProcess:
    """Drives one `python -m rlm.repl` subprocess over the JSON-lines protocol."""

    def __init__(self, env: dict[str, str] | None = None) -> None:
        env = {
            **os.environ,
            "PYTHONPATH": SRC + os.pathsep + os.environ.get("PYTHONPATH", ""),
            **(env or {}),
        }
        self.spawned_at = time.monotonic()
        self.proc = subprocess.Popen(
            [sys.executable, "-m", "rlm.repl"],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
            text=True,
            env=env,
        )
        self.raw_lines: list[str] = []
        self._lines: queue.Queue[object] = queue.Queue()
        threading.Thread(target=self._read_lines, daemon=True).start()

    def _read_lines(self) -> None:
        assert self.proc.stdout is not None
        try:
            for line in self.proc.stdout:
                self._lines.put(line)
        except ValueError:
            pass  # stdout closed by close() while the thread was blocked on it
        self._lines.put(_EOF)

    def read_event(self, timeout: float = 30.0) -> dict:
        try:
            line = self._lines.get(timeout=timeout)
        except queue.Empty:
            raise TimeoutError("timed out waiting for a protocol event") from None
        if line is _EOF:
            raise EOFError("runtime closed its protocol stream")
        assert isinstance(line, str)
        self.raw_lines.append(line)
        return json.loads(line)

    def ready(self) -> tuple[dict, float]:
        event = self.read_event()
        return event, (time.monotonic() - self.spawned_at) * 1000

    def send(self, request: dict) -> None:
        assert self.proc.stdin is not None
        self.proc.stdin.write(json.dumps(request) + "\n")
        self.proc.stdin.flush()

    def send_raw(self, line: str) -> None:
        assert self.proc.stdin is not None
        self.proc.stdin.write(line + "\n")
        self.proc.stdin.flush()

    def execute(self, rid: str, code: str) -> list[dict]:
        self.send({"type": "execute", "id": rid, "code": code})
        return self.until_done(rid)

    def until_done(self, rid: str) -> list[dict]:
        events = []
        while True:
            event = self.read_event()
            events.append(event)
            if event.get("event") == "done" and event.get("id") == rid:
                return events

    def shutdown(self) -> int:
        self.send({"type": "shutdown", "id": "__shutdown__"})
        self.until_done("__shutdown__")
        return self.proc.wait(timeout=10)

    def close(self) -> None:
        if self.proc.poll() is None:
            self.proc.kill()
            self.proc.wait(timeout=10)
        for stream in (self.proc.stdin, self.proc.stdout):
            if stream is not None:
                stream.close()


def stream_text(events: list[dict], stream: str) -> str:
    return "".join(e["text"] for e in events if e.get("event") == stream)


def one(events: list[dict], kind: str) -> dict | None:
    matches = [e for e in events if e.get("event") == kind]
    return matches[0] if matches else None


def wait_for_host_request(repl: ReplProcess, events: list[dict]) -> dict:
    request = one(events, "host_request")
    while request is None:
        event = repl.read_event()
        if event.get("event") == "host_request":
            request = event
    return request


def reply_ok(repl: ReplProcess, request: dict) -> None:
    repl.send({"type": "host_reply", "id": request["id"], "data": {"status": "ok", "result": {}}})


class ReplTest(unittest.TestCase):
    def setUp(self) -> None:
        self.repl = ReplProcess()
        self.addCleanup(self.repl.close)
        self.ready_event, self.ready_ms = self.repl.ready()

    def enabled_factory_repl(self) -> ReplProcess:
        """One repl whose kernel runs with the factory opt-in gate enabled:
        the agent dir points at a temp dir whose settings.json carries the
        enabled setting in the real shape (the same file `/factory on`
        writes and the daemon's lane advertisement reads), so the
        out-of-band lane answers through the live gate instead of reading
        whatever the host machine's settings happen to say."""
        temp = tempfile.TemporaryDirectory()
        self.addCleanup(temp.cleanup)
        with open(os.path.join(temp.name, "settings.json"), "w", encoding="utf-8") as handle:
            json.dump({"factory": {"enabled": True}}, handle)
        repl = ReplProcess(env={"PRIME_AGENT_CODING_AGENT_DIR": temp.name})
        self.addCleanup(repl.close)
        return repl

    def test_bash_activity_is_available_while_cell_is_running(self):
        self.repl.send({"type": "execute", "id": "cell", "code": "from rlm import bash\nimport asyncio\nh = bash('echo ready; sleep 20'); await asyncio.sleep(20)"})
        # Wait for the activity start display before requesting list.
        while True:
            event = self.repl.read_event()
            data = event.get("data", {}).get("application/vnd.prime-agent.bash-activity+json")
            if data and data.get("active"):
                activity_id = data["id"]
                break
        self.repl.send({"type": "bash_activity", "id": "list", "action": "list"})
        listed = self.repl.until_done("list")[-1]
        self.assertEqual(listed["status"], "ok")
        self.assertEqual(next(row for row in listed["activities"] if row["id"] == activity_id)["status"], "running")
        # The tail can race the child's first output flush: poll the
        # bounded tail until the marker lands (the handle's own test does
        # the same wait).
        deadline = time.time() + 10
        tail = {}
        while time.time() < deadline:
            self.repl.send({"type": "bash_activity", "id": "tail", "action": "tail", "activityId": activity_id})
            tail = self.repl.until_done("tail")[-1]
            if "ready" in tail["tail"]:
                break
            time.sleep(0.05)
        self.assertIn("ready", tail["tail"])
        self.repl.send({"type": "bash_activity", "id": "bad", "action": "kill", "activityId": "unknown"})
        self.assertEqual(self.repl.until_done("bad")[-1]["status"], "error")
        self.repl.send({"type": "bash_activity", "id": "kill", "action": "kill", "activityId": activity_id})
        self.assertTrue(self.repl.until_done("kill")[-1]["killed"])
        self.repl.send({"type": "interrupt", "id": "cell"})
        self.repl.until_done("cell")

    def test_bash_activity_rejects_oversized_ids(self):
        self.repl.send({"type": "bash_activity", "id": "x" * 300, "action": "list"})
        event = self.repl.read_event()
        self.assertEqual(event["event"], "error")
        self.assertEqual(event["ename"], "ProtocolError")
        self.assertIn("256", event["evalue"])

    def test_factory_activity_is_available_while_cell_is_running(self):
        repl = self.enabled_factory_repl()
        repl.send({"type": "execute", "id": "cell", "code": "import asyncio\nawait asyncio.sleep(20)"})
        # The factory graph answers out of band while the cell runs: no
        # live runs exist yet, so the graph action lists the empty registry.
        repl.send({"type": "factory_activity", "id": "g", "action": "graph"})
        listed = repl.until_done("g")[-1]
        self.assertEqual(listed["status"], "ok")
        self.assertEqual(listed["result"]["runs"], [])
        # unknown-run watch answers with the error reply (not a hang)
        repl.send({"type": "factory_activity", "id": "w", "action": "watch", "runId": "nope", "timeoutMs": 100})
        missing = repl.until_done("w")[-1]
        self.assertEqual(missing["status"], "error")
        self.assertIn("unknown factory run", missing["reason"])
        repl.send({"type": "interrupt", "id": "cell"})
        repl.until_done("cell")

    def test_factory_activity_rejects_malformed_frames(self):
        for frame, fragment in (
            ({"type": "factory_activity", "id": "b", "action": "bogus"}, "unknown factory activity action"),
            ({"type": "factory_activity", "id": "x" * 300, "action": "graph"}, "256"),
            (
                {"type": "factory_activity", "id": "t", "action": "watch", "runId": "r", "timeoutMs": "soon"},
                "timeoutMs",
            ),
            ({"type": "factory_activity", "id": "n", "action": "graph", "runId": 5}, "runId"),
        ):
            self.repl.send(frame)
            event = self.repl.read_event()
            self.assertEqual(event["event"], "error", frame)
            self.assertEqual(event["ename"], "ProtocolError")
            self.assertIn(fragment, event["evalue"], frame)

    def test_ready_handshake_and_startup_time(self):
        self.assertEqual(self.ready_event["event"], "ready")
        self.assertEqual(self.ready_event["protocol"], 3)
        major, minor = sys.version_info[:2]
        self.assertTrue(self.ready_event["python"].startswith(f"{major}.{minor}."))
        # Loose bound for loaded CI machines; still catches an order-of-magnitude regression.
        print(f"\n[startup] spawn -> ready: {self.ready_ms:.0f} ms")
        self.assertLess(self.ready_ms, 500)

    def test_result_echo(self):
        events = self.repl.execute("a", "1+1")
        self.assertEqual(one(events, "result")["text"], "2")
        self.assertEqual(one(events, "done")["status"], "ok")

        events = self.repl.execute("b", "x = 5")
        self.assertIsNone(one(events, "result"))

        events = self.repl.execute("c", "None")
        self.assertIsNone(one(events, "result"))

        events = self.repl.execute("d", "_ + 40")
        self.assertEqual(one(events, "result")["text"], "42")

    def test_stdout_stderr_and_direct_fd_writes(self):
        code = "\n".join(
            [
                "import os, sys",
                "print('py-out')",
                "sys.stderr.write('py-err\\n')",
                "os.write(1, b'fd-out\\n')",
                "os.write(2, b'fd-err\\n')",
            ]
        )
        events = self.repl.execute("io", code)
        out = stream_text(events, "stdout")
        err = stream_text(events, "stderr")
        self.assertIn("py-out", out)
        self.assertIn("fd-out", out)
        self.assertIn("py-err", err)
        self.assertIn("fd-err", err)
        # Python-level writes carry the cell id; raw fd bytes are never attributed.
        for event in events:
            if event.get("event") not in ("stdout", "stderr"):
                continue
            if "py-" in event["text"]:
                self.assertEqual(event["id"], "io")
            if "fd-" in event["text"]:
                self.assertIsNone(event["id"])
        # done arrives last, after every byte the cell wrote.
        self.assertEqual(events[-1]["event"], "done")

    def test_top_level_await(self):
        events = self.repl.execute("tla", "import asyncio\nawait asyncio.sleep(0)\n'ok'")
        self.assertEqual(one(events, "result")["text"], "'ok'")
        self.assertEqual(one(events, "done")["status"], "ok")

    def test_background_task_persists_across_cells(self):
        setup = "\n".join(
            [
                "import asyncio",
                "acc = []",
                "async def tick():",
                "    while True:",
                "        acc.append(1)",
                "        await asyncio.sleep(0.01)",
                "task = asyncio.create_task(tick())",
            ]
        )
        self.assertEqual(one(self.repl.execute("bg1", setup), "done")["status"], "ok")
        events = self.repl.execute("bg2", "import asyncio\nawait asyncio.sleep(0.2)\nlen(acc)")
        count = int(one(events, "result")["text"])
        self.assertGreater(count, 1)
        events = self.repl.execute("bg3", "task.cancel()\nimport asyncio\nawait asyncio.sleep(0.05)\nlen(acc)")
        self.assertEqual(one(events, "done")["status"], "ok")

    def test_output_after_done_carries_null_id(self):
        with tempfile.TemporaryDirectory() as tmp:
            trigger = os.path.join(tmp, "go")
            code = "\n".join(
                [
                    "import os, threading, time",
                    "def late():",
                    f"    while not os.path.exists({trigger!r}):",
                    "        time.sleep(0.01)",
                    "    print('late-output', flush=True)",
                    "threading.Thread(target=late, daemon=True).start()",
                ]
            )
            events = self.repl.execute("late", code)
            self.assertEqual(one(events, "done")["status"], "ok")
            # `done` is the last event carrying this cell's id.
            tagged = [e for e in events if e.get("id") == "late"]
            self.assertEqual(tagged[-1]["event"], "done")
            # Release the background writer only after `done` was observed; its
            # between-cell output must be emitted with a null id.
            with open(trigger, "w"):
                pass
            deadline = time.monotonic() + 5
            late_events: list[dict] = []
            while time.monotonic() < deadline:
                try:
                    event = self.repl.read_event(timeout=0.5)
                except TimeoutError:
                    continue
                late_events.append(event)
                if event.get("event") == "stdout" and "late-output" in event["text"]:
                    break
            self.assertIn("late-output", stream_text(late_events, "stdout"))
            for event in late_events:
                self.assertIsNone(event.get("id"))

    def test_background_thread_and_fd_output_during_later_cell_is_null(self):
        # Cross-cell misattribution repro: a thread and a direct fd write from
        # cell1 land while cell2 runs; neither may carry cell2's id.
        code = "\n".join(
            [
                "import os, threading, time",
                "def late_print():",
                "    time.sleep(0.6)",
                "    print('SECRET-py', flush=True)",
                "def late_fd():",
                "    time.sleep(0.7)",
                "    os.write(1, b'SECRET-fd\\n')",
                "threading.Thread(target=late_print, daemon=True).start()",
                "threading.Thread(target=late_fd, daemon=True).start()",
            ]
        )
        events = self.repl.execute("cell1", code)
        self.assertEqual(one(events, "done")["status"], "ok")
        events = self.repl.execute("cell2", "import time\ntime.sleep(1.2)")
        self.assertEqual(one(events, "done")["status"], "ok")
        # The SECRET lines may land during cell2 or right after; scan until both seen.
        deadline = time.monotonic() + 5
        while time.monotonic() < deadline:
            text = stream_text(events, "stdout")
            if "SECRET-py" in text and "SECRET-fd" in text:
                break
            try:
                events.append(self.repl.read_event(timeout=0.5))
            except TimeoutError:
                continue
        for event in events:
            if event.get("event") == "stdout" and "SECRET" in event["text"]:
                self.assertIsNone(event["id"])
        text = stream_text(events, "stdout")
        self.assertIn("SECRET-py", text)
        self.assertIn("SECRET-fd", text)

    def test_cell_own_direct_fd_write_is_null_but_arrives_before_done(self):
        events = self.repl.execute("rawfd", "import os\nos.write(1, b'raw\\n')\nprint('tagged')")
        done_index = next(i for i, e in enumerate(events) if e.get("event") == "done")
        raw = next(e for e in events if e.get("event") == "stdout" and "raw" in e["text"])
        self.assertIsNone(raw["id"])
        self.assertLess(events.index(raw), done_index)
        tagged = next(e for e in events if e.get("event") == "stdout" and "tagged" in e["text"])
        self.assertEqual(tagged["id"], "rawfd")

    def test_drain_finalizes_incomplete_raw_utf8_before_done(self):
        first = self.repl.execute("partial-utf8", "import os\nos.write(1, b'\\xe2\\x82')")
        replacement = next(e for e in first if e.get("event") == "stdout")
        self.assertEqual(replacement["text"], "\ufffd")
        self.assertLess(first.index(replacement), first.index(one(first, "done")))

        second = self.repl.execute("continuation-utf8", "os.write(1, b'\\xac')")
        self.assertEqual(stream_text(second, "stdout"), "\ufffd")
        self.assertNotIn("€", stream_text(second, "stdout"))

    def test_hostile_deeply_nested_json_line_does_not_kill_reader(self):
        # json.loads raises RecursionError on pathological nesting; the reader
        # thread must survive and keep serving.
        self.repl.send_raw("[" * 100_000)
        error = self.repl.read_event()
        self.assertEqual(error["event"], "error")
        self.assertEqual(error["ename"], "ProtocolError")
        follow = self.repl.execute("after-hostile", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")
        self.assertEqual(one(follow, "done")["status"], "ok")

    def test_unhashable_request_type_does_not_kill_reader(self):
        self.repl.send({"type": []})
        error = self.repl.read_event()
        self.assertEqual(error["event"], "error")
        self.assertEqual(error["ename"], "ProtocolError")
        self.repl.send({"type": {"x": 1}, "id": 5})
        error = self.repl.read_event()
        self.assertEqual(error["ename"], "ProtocolError")
        follow = self.repl.execute("after-unhashable", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")
        self.assertEqual(one(follow, "done")["status"], "ok")

    def test_duplicate_inflight_id_rejected_and_original_still_interruptible(self):
        self.repl.send({"type": "execute", "id": "dup", "code": "import time\nwhile True:\n    time.sleep(0.05)"})
        time.sleep(0.3)
        self.repl.send({"type": "execute", "id": "dup", "code": "print('imposter')"})
        error = self.repl.read_event()
        self.assertEqual(error["event"], "error")
        self.assertEqual(error["ename"], "ProtocolError")
        self.assertIn("duplicate", error["evalue"])
        # The original request is unaffected and its targeted interrupt still lands.
        self.repl.send({"type": "interrupt", "id": "dup"})
        events = self.repl.until_done("dup")
        self.assertEqual(one(events, "error")["ename"], "KeyboardInterrupt")
        self.assertEqual(one(events, "done")["status"], "error")
        self.assertNotIn("imposter", stream_text(events, "stdout"))
        follow = self.repl.execute("after-dup", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")

    def test_large_buffer_write_survives_short_pipe_writes(self):
        # 256 KiB exceeds the 64 KiB pipe capacity; the binary proxy must loop
        # until every byte is written.
        code = "\n".join(
            [
                "import sys",
                "n = sys.stdout.buffer.write(b'x' * 262144)",
                "sys.stdout.buffer.flush()",
                "print('wrote', n)",
            ]
        )
        events = self.repl.execute("bigbuf", code)
        self.assertEqual(one(events, "done")["status"], "ok")
        raw = "".join(
            e["text"] for e in events if e.get("event") == "stdout" and e.get("id") is None
        )
        self.assertEqual(raw.count("x"), 262144)
        # Cross-channel ordering is not guaranteed: raw x-chunks may interleave
        # between print()'s tagged fragments, so join only the tagged channel.
        tagged = "".join(
            e["text"] for e in events if e.get("event") == "stdout" and e.get("id") == "bigbuf"
        )
        self.assertIn("wrote 262144", tagged)

    def test_interrupt_without_pthread_kill_cancels_awaited_cell(self):
        # Windows fallback seam: with pthread_kill absent the reader cancels
        # the active task on the loop; an await-suspended cell still interrupts.
        code = "\n".join(
            [
                "import signal",
                "if hasattr(signal, 'pthread_kill'):",
                "    del signal.pthread_kill",
                "import asyncio",
                "await asyncio.sleep(30)",
            ]
        )
        self.repl.send({"type": "execute", "id": "nokill", "code": code})
        time.sleep(0.4)
        self.repl.send({"type": "interrupt"})
        events = self.repl.until_done("nokill")
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertEqual(one(events, "done")["status"], "error")

    def test_stdout_buffer_write_works_and_surfaces_as_null(self):
        # Libraries write bytes via sys.stdout.buffer; the tagged writer must
        # expose a working buffer whose bytes surface (null-attributed) before done.
        events = self.repl.execute(
            "bufw", "import sys\nsys.stdout.buffer.write(b'buffer-bytes\\n')\nsys.stdout.buffer.flush()"
        )
        self.assertEqual(one(events, "done")["status"], "ok")
        buffered = next(e for e in events if e.get("event") == "stdout" and "buffer-bytes" in e["text"])
        self.assertIsNone(buffered["id"])
        self.assertLess(events.index(buffered), events.index(one(events, "done")))

    def test_stdout_buffer_write_rejects_int(self):
        # A real stdout.buffer raises TypeError for ints; bytes(5) would emit five NULs.
        events = self.repl.execute("bufint", "import sys\nsys.stdout.buffer.write(5)")
        self.assertEqual(one(events, "error")["ename"], "TypeError")
        self.assertEqual(one(events, "done")["status"], "error")

    def test_asyncio_task_output_keeps_spawning_cell_id(self):
        code = "\n".join(
            [
                "import asyncio",
                "async def late():",
                "    await asyncio.sleep(0.3)",
                "    print('task-output', flush=True)",
                "_t = asyncio.create_task(late())",
            ]
        )
        events = self.repl.execute("spawn", code)
        self.assertEqual(one(events, "done")["status"], "ok")
        events = self.repl.execute("next", "import asyncio\nawait asyncio.sleep(0.6)")
        late = next(e for e in events if e.get("event") == "stdout" and "task-output" in e["text"])
        self.assertEqual(late["id"], "spawn")

    def test_interrupted_await_bash_leaves_no_side_effects(self):
        # One-shot `await bash(...)` (the %%bash-rewrite pattern) must not leak
        # the command past an interrupt.
        with tempfile.TemporaryDirectory() as tmp:
            marker = os.path.join(tmp, "marker")
            code = f"from rlm import bash\nr = await bash('sleep 1.5 && touch {marker}')"
            self.repl.send({"type": "execute", "id": "ibash", "code": code})
            time.sleep(0.4)
            self.repl.send({"type": "interrupt"})
            events = self.repl.until_done("ibash")
            error = one(events, "error")
            self.assertEqual(error["ename"], "KeyboardInterrupt")
            self.assertEqual(one(events, "done")["status"], "error")
            time.sleep(1.6)
            self.assertFalse(os.path.exists(marker))

    def test_interrupted_await_inside_bounded_window_still_kills(self):
        # The bounded wait observes an interrupt instead of abandoning on it:
        # inside the window the owned await keeps its kill-on-cancel contract.
        with tempfile.TemporaryDirectory() as tmp:
            marker = os.path.join(tmp, "marker")
            code = "\n".join(
                [
                    "import rlm",
                    "rlm._set_completion_notices_wired(True)",
                    "from rlm import bash",
                    f"r = await bash('sleep 1.5 && touch {marker}')",
                ]
            )
            self.repl.send({"type": "execute", "id": "ibash-bounded", "code": code})
            time.sleep(0.4)
            self.repl.send({"type": "interrupt"})
            events = self.repl.until_done("ibash-bounded")
            self.assertEqual(one(events, "error")["ename"], "KeyboardInterrupt")
            self.assertEqual(one(events, "done")["status"], "error")
            time.sleep(1.6)
            self.assertFalse(os.path.exists(marker))

    def _interrupt_after_running(self, rid: str, code: str) -> list[dict]:
        self.repl.send({"type": "execute", "id": rid, "code": code})
        # Give the cell time to enter its blocking region before interrupting.
        time.sleep(0.4)
        self.repl.send({"type": "interrupt"})
        return self.repl.until_done(rid)

    def test_interrupt_sync_blocking(self):
        events = self._interrupt_after_running(
            "sync", "import time\nwhile True:\n    time.sleep(0.05)"
        )
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertNotIn("repl.py", "".join(error["traceback"]))
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-sync", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")

    def test_interrupt_survives_cell_rebinding_sigint(self):
        # A cell that ignores SIGINT must not break protocol interrupts for later cells.
        events = self.repl.execute(
            "rebind", "import signal\nsignal.signal(signal.SIGINT, signal.SIG_IGN)"
        )
        self.assertEqual(one(events, "done")["status"], "ok")
        events = self._interrupt_after_running(
            "sync-after-rebind", "import time\nwhile True:\n    time.sleep(0.05)"
        )
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-rebind", "5+5")
        self.assertEqual(one(follow, "result")["text"], "10")

    def test_interrupt_await_suspended(self):
        events = self._interrupt_after_running(
            "await", "import asyncio\nawait asyncio.sleep(1e9)"
        )
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertIn("await asyncio.sleep(1e9)", "".join(error["traceback"]))
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-await", "2+2")
        self.assertEqual(one(follow, "result")["text"], "4")

    def test_interrupt_sync_blocked_in_selectors(self):
        events = self._interrupt_after_running(
            "sel", "import selectors\ns = selectors.DefaultSelector()\ns.select()"
        )
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertNotIn("repl.py", "".join(error["traceback"]))
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-sel", "3+3")
        self.assertEqual(one(follow, "result")["text"], "6")

    def test_interrupt_await_with_loop_hogging_background_task(self):
        # A sync-blocked background task hogs the only thread; the interrupt kills it
        # so the foreground cancel can take effect.
        code = "\n".join(
            [
                "import asyncio, time",
                "async def hog():",
                "    while True:",
                "        time.sleep(0.05)",
                "hog_task = asyncio.create_task(hog())",
                "await asyncio.sleep(1e9)",
            ]
        )
        events = self._interrupt_after_running("fg", code)
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("hog-fate", "type(hog_task.exception()).__name__")
        self.assertEqual(one(follow, "result")["text"], "'KeyboardInterrupt'")
        follow = self.repl.execute("after-hog", "7+7")
        self.assertEqual(one(follow, "result")["text"], "14")

    def test_interrupt_written_back_to_back_with_execute(self):
        execute = json.dumps({"type": "execute", "id": "race", "code": "import asyncio\nawait asyncio.sleep(1e9)"})
        interrupt = json.dumps({"type": "interrupt"})
        assert self.repl.proc.stdin is not None
        self.repl.proc.stdin.write(execute + "\n" + interrupt + "\n")
        self.repl.proc.stdin.flush()
        events = self.repl.until_done("race")
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-race", "5+5")
        self.assertEqual(one(follow, "result")["text"], "10")

    def test_stale_target_from_finished_interrupt_ignores_later_sigint_on_reused_id(self):
        # A targeted interrupt completes "reuse"; a later request reusing the id
        # must not be cancelled by a delayed/external SIGINT that only matches
        # the stale target of the finished request.
        events = self._interrupt_after_running("reuse", "import time\nwhile True:\n    time.sleep(0.05)")
        self.assertEqual(one(events, "error")["ename"], "KeyboardInterrupt")
        self.repl.send({"type": "execute", "id": "reuse", "code": "import time\ntime.sleep(1.5)\nprint('survived')"})
        time.sleep(0.4)  # let the cell enter its sleep before the stray SIGINT
        os.kill(self.repl.proc.pid, signal.SIGINT)
        events = self.repl.until_done("reuse")
        self.assertIsNone(one(events, "error"))
        self.assertEqual(one(events, "done")["status"], "ok")
        self.assertIn("survived", stream_text(events, "stdout"))

    def test_interrupt_during_slow_repr_cancels_finishing_request(self):
        # The cell body finishes instantly; the interrupt lands while the
        # trailing-expression repr is sleeping (post-run finishing window).
        code = "\n".join(
            [
                "import time",
                "class SlowRepr:",
                "    def __repr__(self):",
                "        time.sleep(600)",
                "        return 'late'",
                "SlowRepr()",
            ]
        )
        events = self._interrupt_after_running("slowrepr", code)
        error = one(events, "error")
        self.assertEqual(error["ename"], "KeyboardInterrupt")
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-slowrepr", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")

    def test_traceback_clean_with_source_line(self):
        code = "def boom():\n    raise ValueError('nope')\nboom()"
        events = self.repl.execute("tb", code)
        error = one(events, "error")
        self.assertEqual(error["ename"], "ValueError")
        self.assertEqual(error["evalue"], "nope")
        text = "".join(error["traceback"])
        self.assertIn("<cell-", text)
        self.assertIn("raise ValueError('nope')", text)
        self.assertNotIn("repl.py", text)
        self.assertNotIn("\x1b[", text)

    def test_syntax_error(self):
        events = self.repl.execute("syn", "def broken(:\n    pass")
        error = one(events, "error")
        self.assertEqual(error["ename"], "SyntaxError")
        text = "".join(error["traceback"])
        self.assertIn("<cell-", text)
        self.assertNotIn("repl.py", text)
        self.assertNotIn("ast.py", text)
        self.assertEqual(one(events, "done")["status"], "error")

    def test_snapshot_restore_roundtrip(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "kernel-state.json")
            setup = "\n".join(
                [
                    "import socket",
                    "x = 41",
                    "def bump(n):",
                    "    return n + 1",
                    "sock = socket.socket()",
                ]
            )
            self.assertEqual(one(self.repl.execute("s1", setup), "done")["status"], "ok")
            self.repl.send({"type": "snapshot", "id": "s2", "path": path, "manifest_path": manifest_path})
            done = one(self.repl.until_done("s2"), "done")
            self.assertEqual(done["status"], "ok")
            self.assertEqual(sorted(done["saved"]), ["bump", "socket", "x"])
            self.assertEqual([s["name"] for s in done["skipped"]], ["sock"])
            self.assertNotIn("asyncio", done["saved"])
            self.assertEqual(
                sorted(os.listdir(tmp)), ["kernel-state.dill", "kernel-state.json"]
            )  # no temp files survive a successful commit
            with open(manifest_path) as fh:
                manifest = json.load(fh)
            self.assertEqual(manifest["version"], 1)
            self.assertEqual(manifest["savedNames"], done["saved"])
            self.assertEqual(manifest["bytes"], done["bytes"])
            self.assertIn("pythonVersion", manifest)
            self.assertIn("timestamp", manifest)

            fresh = ReplProcess()
            self.addCleanup(fresh.close)
            fresh.ready()
            fresh.send({"type": "restore", "id": "r1", "path": path})
            done = one(fresh.until_done("r1"), "done")
            self.assertEqual(done["status"], "ok")
            self.assertEqual(sorted(done["restored"]), ["bump", "socket", "x"])
            events = fresh.execute("r2", "bump(x)")
            self.assertEqual(one(events, "result")["text"], "42")
            self.assertEqual(fresh.shutdown(), 0)

    def test_snapshot_skips_off_cell_bash_handles(self):
        # A handle created outside any cell (here: a plain thread) carries no
        # unpicklable cell-task reference, so dill would happily persist its
        # pipe fds; restoring a saved fd number reopens (and closes) it in the
        # new kernel, killing whatever owns the fd there.
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "kernel-state.json")
            setup = (
                "import threading\n"
                "from rlm import bash\n"
                "hs = []\n"
                "t = threading.Thread(target=lambda: hs.append(bash('echo done-h1')))\n"
                "t.start()\n"
                "t.join()\n"
                "h1 = hs[0]\n"
                "await h1\n"
                "del t\n"
                "keep = 1\n"
            )
            self.assertEqual(one(self.repl.execute("s1", setup), "done")["status"], "ok")
            self.repl.send(
                {"type": "snapshot", "id": "s2", "path": path, "manifest_path": manifest_path}
            )
            done = one(self.repl.until_done("s2"), "done")
            self.assertEqual(done["status"], "ok")
            skipped = {entry["name"]: entry["reason"] for entry in done["skipped"]}
            self.assertEqual(sorted(skipped), ["h1", "hs"])
            for reason in skipped.values():
                self.assertIn("live process handle", reason)
            self.assertIn("keep", done["saved"])

    @unittest.skipIf(os.name == "nt", "pickled raw fd numbers are a POSIX landmine")
    def test_restore_refuses_to_reopen_pickled_raw_fds(self):
        # dill serializes a pipe-backed file as its raw fd NUMBER; restoring a
        # saved closed one reopens that number in the new kernel and closes it
        # again, killing whatever owns the fd now (the event loop's self-pipe).
        import dill

        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        from rlm import repl as repl_module

        fresh = ReplProcess()
        self.addCleanup(fresh.close)
        fresh.ready()
        # The loop's self-pipe READ end is the wakeup fd the selector waits on:
        # reopening its number from a snapshot and closing it parks the kernel
        # in select forever (nothing left can wake the loop).
        events = fresh.execute(
            "fd", "import asyncio\nasyncio.get_running_loop()._ssock.fileno()"
        )
        fd = int(one(events, "result")["text"])

        class Landmine:
            def __reduce__(self):
                # The exact reconstructor dill saves for a closed pipe-backed
                # file: name is the fd NUMBER.
                return (dill._dill._create_filehandle, (fd, "rb", 0, True, open, False, 0, b""))

        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "kernel-state.json")
            result = repl_module._snapshot_state(
                {"boom": Landmine(), "keep": 7},
                path,
                manifest_path,
                repl_module.DEFAULT_SNAPSHOT_MAX_BYTES,
                repl_module.DEFAULT_SNAPSHOT_MAX_VARIABLE_BYTES,
                False,
            )
            self.assertEqual(result["saved"], ["boom", "keep"])

            fresh.send({"type": "restore", "id": "r1", "path": path})
            done = one(fresh.until_done("r1"), "done")
            self.assertEqual(done["status"], "ok")
            failed = {entry["name"]: entry["reason"] for entry in done["failed"]}
            self.assertIn(f"refusing to reopen raw file descriptor {fd}", failed["boom"])
            self.assertEqual(done["restored"], ["keep"])
            # The bare await parks the loop with no timer of its own: only a
            # live self-pipe wakeup can resolve it, and if the guard regressed
            # the request would never be served at all (the harness's read
            # timeout bounds that failure).
            probe = (
                "import asyncio, threading\n"
                "loop = asyncio.get_running_loop()\n"
                "fut = loop.create_future()\n"
                "threading.Timer(0.3, lambda: loop.call_soon_threadsafe(\n"
                "    lambda: fut.done() or fut.set_result('woken'))).start()\n"
                "await fut\n"
            )
            events = fresh.execute("wakeup-probe", probe)
            self.assertEqual(one(events, "done")["status"], "ok")
            self.assertEqual(one(events, "result")["text"], "'woken'")

    def test_restore_never_reopens_pickled_file_handles(self):
        # dill saves a file object as (name, mode) and its revival reopens the
        # path with that mode: "w" truncated the user's file on every restore
        # even when the handle was closed (discussion #3085).
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        from rlm import repl as repl_module

        with tempfile.TemporaryDirectory() as tmp:
            target = os.path.join(tmp, "notes.txt")
            handle = open(target, "w")
            handle.close()
            with open(target, "w") as fh:
                fh.write("precious")
            # A handle nested in a container takes the same reconstructor.
            ns = {"handle": handle, "nested": {"inner": [handle]}}
            path = os.path.join(tmp, "state", "kernel-state.dill")
            manifest_path = os.path.join(tmp, "state", "kernel-state.json")
            result = repl_module._snapshot_state(
                ns,
                path,
                manifest_path,
                repl_module.DEFAULT_SNAPSHOT_MAX_BYTES,
                repl_module.DEFAULT_SNAPSHOT_MAX_VARIABLE_BYTES,
                False,
            )
            self.assertEqual(result["saved"], ["handle", "nested"])

            restored_ns = {}
            result = repl_module._restore_state(restored_ns, path)
            self.assertEqual((result["restored"], result["failed"]), (["handle", "nested"], []))
            with open(target) as fh:
                self.assertEqual(fh.read(), "precious")
            restored = restored_ns["handle"]
            self.assertEqual((restored.name, restored.mode, restored.closed), (target, "w", True))
            self.assertIsInstance(restored_ns["nested"]["inner"][0], repl_module._RestoredFileStub)
            for call in (lambda: restored.write("x"), restored.read, restored.readline):
                with self.assertRaisesRegex(ValueError, "closed file"):
                    call()

    def test_stdin_eof_flushes_final_snapshot(self):
        # Host death (EOF, no shutdown request) must persist the namespace
        # tail that postdates the last explicit snapshot.
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "kernel-state.json")
            self.assertEqual(one(self.repl.execute("s1", "x = 1"), "done")["status"], "ok")
            self.repl.send({"type": "snapshot", "id": "s2", "path": path, "manifest_path": manifest_path})
            self.assertEqual(one(self.repl.until_done("s2"), "done")["status"], "ok")
            self.assertEqual(one(self.repl.execute("s3", "x = 42"), "done")["status"], "ok")
            assert self.repl.proc.stdin is not None
            self.repl.proc.stdin.close()
            self.assertEqual(self.repl.proc.wait(timeout=10), 0)

            fresh = ReplProcess()
            self.addCleanup(fresh.close)
            fresh.ready()
            fresh.send({"type": "restore", "id": "r1", "path": path})
            self.assertEqual(one(fresh.until_done("r1"), "done")["status"], "ok")
            events = fresh.execute("r2", "x")
            self.assertEqual(one(events, "result")["text"], "42")

    def test_stdin_eof_without_prior_snapshot_keeps_payload(self):
        # Until this process committed a snapshot of its own, an EOF must
        # not overwrite the on-disk payload with a namespace the host never
        # considered durable (e.g. a restore that failed to run).
        import dill

        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            with open(path, "wb") as fh:
                dill.dump({"x": dill.dumps(7)}, fh)
            self.assertEqual(one(self.repl.execute("s1", "x = 999"), "done")["status"], "ok")
            assert self.repl.proc.stdin is not None
            self.repl.proc.stdin.close()
            self.assertEqual(self.repl.proc.wait(timeout=10), 0)

            fresh = ReplProcess()
            self.addCleanup(fresh.close)
            fresh.ready()
            fresh.send({"type": "restore", "id": "r1", "path": path})
            self.assertEqual(one(fresh.until_done("r1"), "done")["status"], "ok")
            events = fresh.execute("r2", "x")
            self.assertEqual(one(events, "result")["text"], "7")

    def test_restore_skips_ipython_injected_names(self):
        import dill

        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            payload = {
                "kept": dill.dumps(7),
                "In": dill.dumps(["cell"]),
                "Out": dill.dumps({1: "x"}),
                "get_ipython": dill.dumps(None),
            }
            with open(path, "wb") as fh:
                dill.dump(payload, fh)
            self.repl.send({"type": "restore", "id": "r", "path": path})
            done = one(self.repl.until_done("r"), "done")
            self.assertEqual(done["status"], "ok")
            self.assertEqual(done["restored"], ["kept"])
            events = self.repl.execute("chk", "'In' in dir()")
            self.assertEqual(one(events, "result")["text"], "False")

    def test_restore_revives_functions_with_live_globals_pr2471(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "state.dill")
            self.repl.execute("fn1", "G = 1\ndef reader():\n    return G\ndef prober():\n    return late")
            # priv.__globals__ is the private exec dict pn, not ns: drives backfill.
            self.repl.execute("fn0", "exec('SECRET = 42\\ndef priv():\\n    return SECRET', pn:={'__name__': '__main__'})\npriv = pn['priv']")
            self.repl.send({"type": "snapshot", "id": "fn2", "path": path, "manifest_path": os.path.join(tmp, "state.json")})
            self.repl.send({"type": "restore", "id": "fn3", "path": path})
            self.assertEqual(one(self.repl.until_done("fn3"), "done")["status"], "ok")
            events = self.repl.execute("fn4", "G = 2\nreader()")
            self.assertEqual(one(events, "result")["text"], "2")
            events = self.repl.execute("fn5", "late = 'live'\nprober()")
            self.assertEqual(one(events, "result")["text"], "'live'")
            events = self.repl.execute("fn6", "priv()")
            self.assertEqual(one(events, "result")["text"], "42")

    def test_restore_revives_partial_wrapped_functions_pr2471(self):
        # dill revives a partial's wrapped __main__ function with frozen globals.
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "state.dill")
            self.repl.execute("pt1", "import functools\nG = 1\ndef base():\n    return G\nwrapped = functools.partial(base)")
            self.repl.send({"type": "snapshot", "id": "pt2", "path": path, "manifest_path": os.path.join(tmp, "state.json")})
            self.repl.send({"type": "restore", "id": "pt3", "path": path})
            self.assertEqual(one(self.repl.until_done("pt3"), "done")["status"], "ok")
            events = self.repl.execute("pt4", "G = 2\nwrapped()")
            self.assertEqual(one(events, "result")["text"], "2")

    def _snapshot_restore(self, rid: str, code: str, tmp: str) -> None:
        self.assertEqual(one(self.repl.execute(rid + "0", code), "done")["status"], "ok")
        self.repl.send({"type": "snapshot", "id": rid + "1", "path": os.path.join(tmp, "s.dill"), "manifest_path": os.path.join(tmp, "s.json")})
        self.repl.send({"type": "restore", "id": rid + "2", "path": os.path.join(tmp, "s.dill")})
        self.assertEqual(one(self.repl.until_done(rid + "2"), "done")["status"], "ok")

    def test_restore_rebuilt_partial_keeps_attributes_and_args_pr2471(self):
        code = (
            "import functools\nG = 1\ndef helper():\n    return G\ndef apply(fn):\n    return fn()\n"
            "wrapped = functools.partial(apply, helper)\nwrapped.label = 'x'"
        )
        with tempfile.TemporaryDirectory() as tmp:
            self._snapshot_restore("pa", code, tmp)
            self.assertEqual(one(self.repl.execute("pa4", "wrapped.label"), "result")["text"], "'x'")
            self.assertEqual(one(self.repl.execute("pa5", "G = 2\nwrapped()"), "result")["text"], "2")

    def test_restore_backfill_skips_excluded_names_pr2471(self):
        code = (
            "exec('PUB = 1\\n_hidden = 2\\nIn = 3\\nOut = 4\\ndef user():\\n    return (PUB, _hidden, In, Out)', pn:={'__name__': '__main__'})\n"
            "user = pn['user']"
        )
        with tempfile.TemporaryDirectory() as tmp:
            self._snapshot_restore("ex", code, tmp)
            probe = "('PUB' in dir(), '_hidden' in dir(), 'In' in dir(), 'Out' in dir())"
            self.assertEqual(one(self.repl.execute("ex4", probe), "result")["text"], "(True, False, False, False)")

    def test_restore_revives_callables_in_defaults_and_closures_pr2471(self):
        code = ("G = 1\ndef helper():\n    return G\nrun = lambda fn=helper: fn()\nrun2 = lambda *, fn=helper: fn()\nclosed = (lambda fn: lambda: fn())(helper)\n"
                "def make():\n    n = 0\n    def get():\n        return n\n    def set(v):\n        nonlocal n\n        n = v\n    get.set = set\n    return get\ncounter = make()\nrun.callback = helper")
        with tempfile.TemporaryDirectory() as tmp:
            self._snapshot_restore("dc", code, tmp)
            self.assertEqual(one(self.repl.execute("dc4", "G = 2\ncounter.set(5)\n(run(), run2(), closed(), counter(), run.callback())"), "result")["text"], "(2, 2, 2, 5, 2)")

    def test_restore_publishes_rebuilt_partial_in_backfill_cycle_pr2471(self):
        code = ("exec('import functools\\nG = 1\\ndef base():\\n    return G, wrapped\\nwrapped = functools.partial(base)\\n"
                "def entry():\\n    return wrapped()', pn:={'__name__': '__main__'})\nentry = pn['entry']")
        self._snapshot_restore("bp", code, self.enterContext(tempfile.TemporaryDirectory()))
        self.assertEqual(one(self.repl.execute("bp4", "G = 2\nentry()[0]"), "result")["text"], "2")

    def test_restore_revives_functions_inside_containers_pr2471(self):
        code = "G = 1\ndef reader():\n    return G\ncallbacks = [reader]\nhandlers = {'read': reader}\npair = (reader,)"
        self._snapshot_restore("ct", code, self.enterContext(tempfile.TemporaryDirectory()))
        self.assertEqual(one(self.repl.execute("ct4", "G = 2\n(callbacks[0](), handlers['read'](), pair[0]())"), "result")["text"], "(2, 2, 2)")

    def test_restore_revives_functions_inside_sets_pr2471(self):
        code = "G = 1\ndef reader():\n    return G\ncallbacks = {reader}\nfrozen = frozenset({reader})"
        self._snapshot_restore("st", code, self.enterContext(tempfile.TemporaryDirectory()))
        self.assertEqual(
            one(
                self.repl.execute("st4", "G = 2\n(next(iter(callbacks))(), next(iter(frozen))())"),
                "result",
            )["text"],
            "(2, 2)",
        )

    def test_restore_self_referential_partial_survives_pr2471(self):
        code = (
            "import functools\nG = 1\ndef base():\n    return G\n"
            "p = functools.partial(base)\np.self = p\nq = functools.partial(base)\nr = functools.partial(base)\nq.peer = r\nr.peer = q"
        )
        self._snapshot_restore("sp", code, self.enterContext(tempfile.TemporaryDirectory()))
        # Cross-record identity is the documented per-record aliasing limit
        # (each record unpickles independently); the cycle guarantees are:
        # no RecursionError, the self-cycle identity within one record, and
        # live globals through the revived peers.
        events = self.repl.execute("sp4", "G = 2\n(p(), p.self is p, q.peer(), r.peer())")
        self.assertEqual(one(events, "result")["text"], "(2, True, 2, 2)")

    def test_restore_revives_function_dictionary_keys_pr2471(self):
        code = "G = 1\ndef reader():\n    return G\ntable = {reader: 'v'}"
        self._snapshot_restore("dk", code, self.enterContext(tempfile.TemporaryDirectory()))
        # The revived key observes live globals and keeps the dict usable;
        # identity with the separately-restored `reader` name is the
        # documented per-record aliasing limit.
        events = self.repl.execute(
            "dk4", "G = 2\nk = next(iter(table))\n(k(), table[k])"
        )
        self.assertEqual(one(events, "result")["text"], "(2, 'v')")

    def test_restore_unchanged_partial_revives_function_attributes_pr2471(self):
        code = "import functools\nG = 1\ndef helper():\n    return G\np = functools.partial(len)\np.callback = helper"
        self._snapshot_restore("up", code, self.enterContext(tempfile.TemporaryDirectory()))
        self.assertEqual(one(self.repl.execute("up4", "G = 2\np.callback()"), "result")["text"], "2")

    def test_restore_rebuilt_partial_revives_function_attributes_pr2471(self):
        code = (
            "import functools\nG = 1\ndef helper():\n    return G\ndef apply(fn):\n    return fn()\n"
            "wrapped = functools.partial(apply, helper)\nwrapped.callback = helper"
        )
        self._snapshot_restore("pc", code, self.enterContext(tempfile.TemporaryDirectory()))
        self.assertEqual(one(self.repl.execute("pc4", "G = 2\nwrapped.callback()"), "result")["text"], "2")

    def test_snapshot_skips_lone_surrogate_names_pr2478(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "kernel-state.json")
            # A lone surrogate cannot ride a source literal (compile rejects
            # it); runtime-constructed keys are the reachable path.
            self.repl.execute("sg1", "globals()[chr(0xD800)] = 1\nkeep = 2")
            self.repl.send({"type": "snapshot", "id": "sg2", "path": path, "manifest_path": manifest_path})
            done = one(self.repl.until_done("sg2"), "done")
            self.assertEqual(done["status"], "ok")
            self.assertEqual(done["saved"], ["keep"])
            self.assertEqual(len(done["skipped"]), 1)
            self.assertEqual(done["skipped"][0]["name"], "\ud800")
            self.assertIn("UnicodeEncodeError", done["skipped"][0]["reason"])

    def test_snapshot_prune_oversized(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "kernel-state.json")
            self.repl.execute("p1", "small = 1\nbig = b'x' * 100_000")
            self.repl.send(
                {
                    "type": "snapshot",
                    "id": "p2",
                    "path": path,
                    "manifest_path": manifest_path,
                    "max_variable_bytes": 1024,
                    "prune_oversized": True,
                }
            )
            done = one(self.repl.until_done("p2"), "done")
            self.assertEqual(done["status"], "ok")
            self.assertEqual(done["saved"], ["small"])
            self.assertEqual(done["pruned"], ["big"])
            events = self.repl.execute("p3", "'big' in dir()")
            self.assertEqual(one(events, "result")["text"], "False")

    def test_prune_measures_the_current_value_2478(self):
        # Redefinition or in-place shrink after an oversized skip: prune must re-measure.
        for cell in ("def big(): pass", "big.clear()"):
            with self.subTest(cell=cell):
                with tempfile.TemporaryDirectory() as tmp:
                    base = {"type": "snapshot", "path": os.path.join(tmp, "kernel-state.dill"),
                            "manifest_path": os.path.join(tmp, "kernel-state.json"), "max_variable_bytes": 1024}
                    self.repl.execute("pk1", "big = bytearray(b'x' * 100_000)\nkeep = 1")
                    self.repl.send({"id": "pk2", **base})
                    self.assertEqual(one(self.repl.until_done("pk2"), "done")["status"], "ok")
                    self.repl.execute("pk3", cell)
                    self.repl.send({"id": "pk4", "prune_oversized": True, **base})
                    done = one(self.repl.until_done("pk4"), "done")
                    self.assertEqual(done["status"], "ok")
                    self.assertEqual(done["pruned"], [])
                    self.assertEqual(done["saved"], ["big", "keep"])

    def test_emit_display(self):
        payloads = {
            "application/vnd.prime-agent.diff+json": {
                "path": "/tmp/file.py",
                "old_str": "a",
                "new_str": "b",
                "start_line": 3,
            },
            "application/vnd.prime-agent.attachment+json": {
                "mime_type": "image/png",
                "data": "aGVsbG8=",
                "path": "/tmp/img.png",
            },
            "application/vnd.prime-agent.agent-message+json": {
                "id": "agentmsg_1",
                "message": "hi",
                "deliveryStatus": "delivered",
                "receiverRole": "parent",
                "target": {"sessionId": "s1"},
            },
        }
        for i, (mime, payload) in enumerate(payloads.items()):
            code = "\n".join(
                [
                    "from rlm.repl import emit",
                    f"emit({{ {mime!r}: {payload!r}, 'text/plain': 'label' }})",
                ]
            )
            events = self.repl.execute(f"emit{i}", code)
            display = one(events, "display")
            self.assertIsNotNone(display)
            self.assertEqual(display["data"][mime], payload)
            self.assertEqual(display["data"]["text/plain"], "label")
            self.assertEqual(display["id"], f"emit{i}")

    def test_emit_nan_payload_errors_in_cell_and_keeps_framing(self):
        # NaN would serialize as non-JSON text and tear protocol framing;
        # emit() must raise in the caller's cell instead.
        code = "from rlm.repl import emit\nemit({'application/json': float('nan')})"
        events = self.repl.execute("emit-nan", code)
        self.assertEqual(one(events, "error")["ename"], "ValueError")
        self.assertEqual(one(events, "done")["status"], "error")
        self.assertIsNone(one(events, "display"))
        follow = self.repl.execute("after-emit-nan", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")
        self.assertEqual(one(follow, "done")["status"], "ok")

    def test_large_write_ships_bounded_stream_frames(self):
        events = self.repl.execute("chunk", "import sys\nsys.stdout.write('x' * 300_000)")
        frames = [e["text"] for e in events if e.get("event") == "stdout"]
        self.assertEqual("".join(frames), "x" * 300_000)
        self.assertTrue(all(len(frame) <= 65536 for frame in frames))

    def test_oversized_text_and_payloads_are_capped(self):
        code = "class C:\n    def __repr__(self):\n        return 'x' * 3_000_000\nC()"
        events = self.repl.execute("big-repr", code)
        expected = "x" * 1_048_576 + "\n[... result truncated at 1048576 characters ...]"
        self.assertEqual(one(events, "result")["text"], expected)
        error = one(self.repl.execute("big-error", "raise ValueError('x' * 3_000_000)"), "error")
        self.assertEqual(error["evalue"], expected)
        self.assertEqual(error["traceback"][-1], "ValueError: " + expected[len("ValueError: ") :])
        events = self.repl.execute("emit-big", "from rlm.repl import emit\nemit({'text/plain': 'x' * 17_000_000})")
        self.assertEqual(one(events, "error")["ename"], "ValueError")
        self.assertEqual(one(events, "done")["status"], "error")
        code = "from rlm.repl import host_request\nawait host_request({'type': 'demo', 'blob': 'x' * 17_000_000})"
        self.assertEqual(one(self.repl.execute("hr-big", code), "error")["ename"], "ValueError")

    def test_bash_integration(self):
        events = self.repl.execute(
            "sh1", "from rlm import bash\nresult = await bash('echo repl-bash')\nresult.output.strip()"
        )
        self.assertEqual(one(events, "result")["text"], "'repl-bash'")

        events = self.repl.execute(
            "sh2", "handle = bash('sleep 600')\nhandle.pid"
        )
        pid = int(one(events, "result")["text"])
        self.assertEqual(self.repl.shutdown(), 0)
        # Shutdown kills live bash process groups; the sleep must be gone.
        deadline = time.monotonic() + 5
        while time.monotonic() < deadline:
            try:
                os.kill(pid, 0)
            except ProcessLookupError:
                return
            time.sleep(0.05)
        self.fail(f"bash child {pid} survived runtime shutdown")

    def test_async_bash_completion_notifies_only_after_an_unawaited_creating_cell(self):
        direct = self.repl.execute(
            "bash-direct", "from rlm import bash\n(await bash('printf direct')).exit_code"
        )
        self.assertIsNone(one(direct, "host_request"))

        eventual = self.repl.execute(
            "bash-eventual",
            "import asyncio\nhandle = bash('printf eventual')\nawait asyncio.sleep(0.1)\n(await handle).exit_code",
        )
        self.assertIsNone(one(eventual, "host_request"))

        started = self.repl.execute(
            "bash-detached", "handle = bash('sleep 0.05; printf detached')\nhandle.pid"
        )
        pid = int(one(started, "result")["text"])
        request = wait_for_host_request(self.repl, started)
        self.assertEqual(
            request["data"],
            {
                "type": "bash.completed",
                "pid": pid,
                "command": "sleep 0.05; printf detached",
                "exitCode": 0,
            },
        )
        reply_ok(self.repl, request)
        inspected = self.repl.execute("bash-inspect", "handle.poll().output")
        self.assertIn("detached", one(inspected, "result")["text"])

    def test_degraded_await_in_creating_cell_still_sends_bash_completion(self):
        # A bounded await that degrades inside the creating cell must count as
        # neither awaited nor consumed, or the [bash-done] notice (the only
        # wake-up) would never fire.
        code = "\n".join(
            [
                "import rlm",
                "rlm._set_completion_notices_wired(True)",
                "from rlm import bash",
                "handle = bash('sleep 1.5; printf degraded')",
                "await handle",
                "handle.pid",
            ]
        )
        events = self.repl.execute("bash-degrade", code)
        pid = int(one(events, "result")["text"])
        request = wait_for_host_request(self.repl, events)
        self.assertEqual(
            request["data"],
            {
                "type": "bash.completed",
                "pid": pid,
                "command": "sleep 1.5; printf degraded",
                "exitCode": 0,
            },
        )
        reply_ok(self.repl, request)

    def test_degraded_await_of_a_persistent_shell_keeps_it_running_to_its_notice(self):
        # The yield window and persistent= compose: the persistent handle's await
        # degrades like any handle's, and the shell (never owned by an await)
        # runs on to its [bash-done] notice.
        temp = tempfile.TemporaryDirectory()
        self.addCleanup(temp.cleanup)
        repl = ReplProcess(
            env={"PRIME_AGENT_CODING_AGENT_DIR": temp.name, "RLM_SESSION_ID": "own-session"}
        )
        self.addCleanup(repl.close)
        repl.ready()
        code = "\n".join(
            [
                "import rlm",
                "rlm._set_completion_notices_wired(True)",
                "from rlm import bash",
                "handle = bash('sleep 1.5; printf persisted', persistent=True)",
                "snapshot = await handle",
                "(snapshot.running, snapshot.handle is handle, handle.pid)",
            ]
        )
        events = repl.execute("persistent-degrade", code)
        running, same, pid = one(events, "result")["text"].strip("()").split(", ")
        self.assertEqual((running, same), ("True", "True"))
        request = wait_for_host_request(repl, events)
        self.assertEqual(
            request["data"],
            {
                "type": "bash.completed",
                "pid": int(pid),
                "command": "sleep 1.5; printf persisted",
                "exitCode": 0,
            },
        )
        reply_ok(repl, request)

    def test_result_read_after_notice_requests_one_withdrawal(self):
        reads = (
            ("poll", "handle.poll().output"),
            ("await", "(await handle).output"),
        )
        for label, read_code in reads:
            with self.subTest(label=label):
                command = f"sleep 0.05; printf withdrawn-{label}"
                started = self.repl.execute(
                    f"withdraw-{label}",
                    f"from rlm import bash\nhandle = bash({command!r})\nhandle.pid",
                )
                pid = int(one(started, "result")["text"])
                notice = wait_for_host_request(self.repl, started)
                self.assertEqual(notice["data"]["type"], "bash.completed")
                reply_ok(self.repl, notice)
                read = self.repl.execute(f"withdraw-{label}-read", read_code)
                self.assertIn(f"withdrawn-{label}", one(read, "result")["text"])
                # The withdrawal must ship ahead of the reading cell's done, or the
                # notice is delivered as a stale turn-boundary notice instead.
                kinds = [event.get("event") for event in read]
                self.assertLess(kinds.index("host_request"), kinds.index("done"))
                request = wait_for_host_request(self.repl, read)
                self.assertEqual(
                    request["data"], {"type": "bash.consumed", "pid": pid, "command": command}
                )
                # Old host: the error reply is dropped silently and the withdrawal never repeats.
                self.repl.send(
                    {"type": "host_reply", "id": request["id"], "data": {"status": "error", "error": "unknown"}}
                )
                if label == "poll":
                    again = self.repl.execute("withdraw-again", "handle.output()\nhandle.tail(1)")
                    self.assertEqual([e for e in again if e.get("event") in ("error", "host_request")], [])

    def test_result_read_before_notice_acceptance_withdraws_at_acceptance(self):
        started = self.repl.execute("early", "from rlm import bash\nhandle = bash('printf early')\nhandle.pid")
        notice = wait_for_host_request(self.repl, started)
        self.assertIsNone(one(self.repl.execute("early-read", "handle.poll().output"), "host_request"))
        reply_ok(self.repl, notice)
        withdrawal = wait_for_host_request(self.repl, [])["data"]
        self.assertEqual(withdrawal, {"type": "bash.consumed", "pid": notice["data"]["pid"], "command": "printf early"})

    def test_detached_read_between_turns_keeps_bash_completion(self):
        # A watcher reading the handle with no cell running reaches nobody: the
        # notice is the only wake-up an idle session gets, so it must survive.
        code = "\n".join(
            [
                "from rlm import bash",
                "import asyncio",
                "handle = bash('sleep 0.2; printf detached-read')",
                "async def watch():",
                "    await handle._wait()",
                "    globals()['seen'] = handle.output()",
                "asyncio.create_task(watch())",
                "handle.pid",
            ]
        )
        started = self.repl.execute("detached-read", code)
        pid = int(one(started, "result")["text"])
        request = wait_for_host_request(self.repl, started)
        self.assertEqual(request["data"]["type"], "bash.completed")
        self.assertEqual(request["data"]["pid"], pid)
        reply_ok(self.repl, request)
        probe = self.repl.execute("detached-read-probe", "await asyncio.sleep(0.05)\nseen")
        self.assertIsNone(one(probe, "host_request"))
        self.assertEqual(one(probe, "result")["text"], "'detached-read'")

    def test_result_read_in_creating_cell_suppresses_bash_completion(self):
        events = self.repl.execute(
            "read-in-cell",
            "from rlm import bash\nimport asyncio\nhandle = bash('printf read-in-cell')\n"
            "await asyncio.wait_for(handle._wait(), 5)\nhandle.output()",
        )
        self.assertEqual(one(events, "result")["text"], "'read-in-cell'")
        probe = self.repl.execute("read-in-cell-probe", "await asyncio.sleep(0.05)")
        self.assertIsNone(one(events, "host_request"))
        self.assertIsNone(one(probe, "host_request"))

    def test_wrapper_awaits_in_creating_cell_suppress_bash_completion(self):
        def task_group(label: str, await_expression: str) -> str:
            return "\n".join(
                [
                    f"handle = bash('printf {label}')",
                    "async def consume():",
                    f"    return {await_expression}",
                    "async with asyncio.TaskGroup() as group:",
                    "    task = group.create_task(consume())",
                    "task.result().output",
                ]
            )

        snippets = {
            "gather": "(await asyncio.gather(bash('printf gather')))[0].output",
            "wait-for": "(await asyncio.wait_for(bash('printf wait-for'), 1)).output",
            "shield": "(await asyncio.shield(bash('printf shield'))).output",
            "nested": "(await asyncio.shield(asyncio.gather(bash('printf nested'))))[0].output",
            "as-completed": (
                "[(await completed).output for completed in "
                "asyncio.as_completed([bash('printf as-completed')])]"
            ),
            "as-completed-delayed-consumer": (
                "handle = bash('sleep 0.15; printf as-completed-delayed-consumer')\n"
                "completed = next(iter(asyncio.as_completed([handle])))\n"
                "await asyncio.sleep(0)\n"
                "(await completed).output"
            ),
            "as-completed-finished-handle": (
                "handle = bash('printf as-completed-finished-handle')\n"
                "task = asyncio.ensure_future(handle)\n"
                "await asyncio.to_thread(handle._done.wait)\n"
                "await asyncio.sleep(0.01)\n"
                "assert task.done()\n"
                "(await handle).output"
            ),
            "as-completed-nested": (
                "[(await completed)[0].output for completed in "
                "asyncio.as_completed([asyncio.shield(asyncio.gather(bash('printf as-completed-nested')))])]"
            ),
            "wait": "\n".join(
                [
                    "handle = bash('printf wait')",
                    "task = asyncio.ensure_future(handle)",
                    "await asyncio.wait({task})",
                    "task.result().output",
                ]
            ),
            "task-group": task_group("task-group", "await handle"),
            "task-group-gather": task_group("task-group-gather", "(await asyncio.gather(handle))[0]"),
            "task-group-shield": task_group("task-group-shield", "await asyncio.shield(handle)"),
        }
        if sys.version_info >= (3, 13):
            snippets["as-completed-async"] = (
                "[completed.result().output async for completed in "
                "asyncio.as_completed([bash('printf as-completed-async')])]"
            )
        for label, snippet in snippets.items():
            with self.subTest(label=label):
                completed = self.repl.execute(
                    f"bash-wrapper-{label}",
                    f"from rlm import bash\nimport asyncio\n{snippet}",
                )
                self.assertIn(label, one(completed, "result")["text"])
                probe = self.repl.execute(f"bash-wrapper-{label}-probe", "await asyncio.sleep(0.05)")
                request = one(probe, "host_request")
                if request is not None:
                    reply_ok(self.repl, request)
                self.assertIsNone(request)

    def test_as_completed_outside_creating_cell_keeps_one_bash_completion(self):
        snippets = {
            "no-await": (
                "iterator = asyncio.as_completed([handle])\n"
                "next(iterator).close()\n"
                "await asyncio.sleep(0.05)"
            ),
            "detached": (
                "async def consume():\n"
                "    for completed in asyncio.as_completed([handle]):\n"
                "        await completed\n"
                "consumer = asyncio.create_task(consume())\n"
                "await asyncio.sleep(0.05)"
            ),
        }
        for label, snippet in snippets.items():
            with self.subTest(label=label):
                command = f"printf {label}"
                events = self.repl.execute(
                    f"as-completed-{label}",
                    f"from rlm import bash\nimport asyncio\nhandle = bash({command!r})\n{snippet}",
                )
                events += self.repl.execute(
                    f"as-completed-{label}-probe", "await asyncio.sleep(0.05)"
                )
                requests = [event for event in events if event.get("event") == "host_request"]
                for request in requests:
                    reply_ok(self.repl, request)
                self.assertEqual(len(requests), 1)
                self.assertEqual(requests[0]["data"]["type"], "bash.completed")
                self.assertEqual(requests[0]["data"]["command"], command)
                self.assertFalse(any(event.get("event") == "error" for event in events))

    def test_background_task_await_does_not_suppress_bash_completion(self):
        code = "\n".join(
            [
                "from rlm import bash",
                "import asyncio",
                "task_handle = bash('sleep 0.05; printf background-waiter')",
                "async def consume():",
                "    globals()['task_result'] = await task_handle",
                "waiter = asyncio.create_task(consume())",
                "bookkeeping = asyncio.get_running_loop().create_future()",
                "def callback_for(marker):",
                "    return lambda _: marker.cancelled()",
                "waiter.add_done_callback(callback_for(bookkeeping))",
                "asyncio.get_running_loop().call_later(0.02, bookkeeping.set_result, None)",
                "await bookkeeping",
                "task_handle.pid",
            ]
        )
        started = self.repl.execute("bash-task-waiter", code)
        pid = int(one(started, "result")["text"])
        request = wait_for_host_request(self.repl, started)
        self.assertEqual(request["data"]["type"], "bash.completed")
        self.assertEqual(request["data"]["pid"], pid)
        reply_ok(self.repl, request)

    def test_bash_activity_and_notice_wait_for_group_reap(self):
        mime = "application/vnd.prime-agent.bash-activity+json"
        for awaited in (False, True):
            with self.subTest(awaited=awaited):
                events = self.repl.execute(
                    "group-start",
                    "from rlm import bash\nimport asyncio\n"
                    "handle = bash('sleep 30 &')\n"
                    + ("await handle\n" if awaited else "")
                    + "await asyncio.wait_for(handle._wait(), 3)\nhandle._group_alive()",
                )
                self.assertEqual(one(events, "result")["text"], "True")
                self.assertIsNone(one(events, "host_request"))
                self.assertFalse(
                    any(event.get("data", {}).get(mime, {}).get("active") is False for event in events)
                )
                events += self.repl.execute("group-stop", "handle.kill()")
                requests = []
                cursor = 0
                while True:
                    for event in events[cursor:]:
                        if event.get("event") == "host_request":
                            requests.append(event)
                            reply_ok(self.repl, event)
                    cursor = len(events)
                    if any(event.get("data", {}).get(mime, {}).get("active") is False for event in events):
                        break
                    events.append(self.repl.read_event())
                self.assertEqual(len(requests), 0 if awaited else 1)
                checked = self.repl.execute(
                    "group-reaped", "await asyncio.wait_for(handle._wait_reaped(), 1)\nhandle._reaped"
                )
                self.assertEqual(one(checked, "result")["text"], "True")

    def test_cancelled_released_bash_await_keeps_completion_notice(self):
        mime = "application/vnd.prime-agent.bash-activity+json"
        for released in (False, True):
            with self.subTest(released=released):
                events = self.repl.execute(
                    "cancel-start",
                    "from rlm import bash\nimport asyncio\n"
                    "handle = bash('sleep 0.15; printf finished')\n"
                    + ("handle.pid\n" if released else "")
                    + "try:\n    await asyncio.wait_for(handle, 0.01)\n"
                    "except TimeoutError:\n    pass\nhandle._group_alive()",
                )
                self.assertEqual(one(events, "result")["text"], str(released))
                requests = []
                cursor = 0
                while True:
                    for event in events[cursor:]:
                        if event.get("event") == "host_request":
                            requests.append(event)
                            reply_ok(self.repl, event)
                    cursor = len(events)
                    if any(event.get("data", {}).get(mime, {}).get("active") is False for event in events):
                        break
                    events.append(self.repl.read_event())
                self.assertEqual(len(requests), 1 if released else 0)
                checked = self.repl.execute("cancel-result", "handle.poll().output")
                self.assertEqual(one(checked, "result")["text"], "'finished'" if released else "''")

    def test_interrupt_during_bash_notifier_construction_rolls_back_activity(self):
        code = "\n".join(
            [
                "from rlm import bash, repl as bridge",
                "import sys, threading, asyncio, inspect",
                "def stop_at_notice_construction(frame, event, arg):",
                "    coro = frame.f_locals.get('coro')",
                "    if (event == 'call' and frame.f_code.co_name == 'create_task'",
                "            and getattr(getattr(coro, 'cr_code', None), 'co_name', None)",
                "            == '_notify_background_completion'):",
                "        globals()['unscheduled_notice'] = coro",
                "        globals()['interrupted_handle'] = coro.cr_frame.f_locals['self']",
                "        bridge.emit({'application/json': {'at_notice_create_task': True}})",
                "        threading.Event().wait(10)",
                "    return stop_at_notice_construction",
                "sys.settrace(stop_at_notice_construction)",
                "handle = bash('sleep 30')",
            ]
        )
        self.repl.send({"type": "execute", "id": "construct", "code": code})
        events = []
        while True:
            event = self.repl.read_event()
            events.append(event)
            if event.get("data", {}).get("application/json", {}).get("at_notice_create_task"):
                break
        self.repl.send({"type": "interrupt", "id": "construct"})
        events += self.repl.until_done("construct")
        self.assertEqual(one(events, "done")["status"], "error")
        self.assertEqual(one(events, "error")["ename"], "KeyboardInterrupt")
        mime = "application/vnd.prime-agent.bash-activity+json"
        activity = [event["data"][mime] for event in events if mime in event.get("data", {})]
        self.assertEqual([item["active"] for item in activity], [True, False])
        self.assertEqual(activity[0]["id"], activity[1]["id"])
        checked = self.repl.execute(
            "construct-check",
            "sys.settrace(None)\n"
            "assert await interrupted_handle._await_group_death(3)\n"
            "(inspect.getcoroutinestate(unscheduled_notice), interrupted_handle._reap_callback, "
            "interrupted_handle._group_alive())",
        )
        self.assertEqual(one(checked, "result")["text"], "('CORO_CLOSED', None, False)")

    def test_rejected_bash_completion_reports_safe_stderr_and_releases_activity(self):
        mime = "application/vnd.prime-agent.bash-activity+json"
        for reply in ({"status": "error", "error": "secret-host-error"}, {}, {"status": "ok"}):
            with self.subTest(reply=reply):
                events = self.repl.execute(
                    "ack-start", "from rlm import bash\nhandle = bash('printf secret-command')"
                )
                request = wait_for_host_request(self.repl, events)
                self.repl.send({"type": "host_reply", "id": request["id"], "data": reply})
                after = []
                while not any(
                    event.get("data", {}).get(mime, {}).get("active") is False for event in after
                ):
                    after.append(self.repl.read_event())
                diagnostic = stream_text(after, "stderr")
                if reply.get("status") == "ok":
                    self.assertEqual(diagnostic, "")
                else:
                    self.assertEqual(
                        diagnostic,
                        f"Background bash completion follow-up for pid {request['data']['pid']} "
                        "was not accepted. Inspect the saved handle with poll(), output(), or tail().\n",
                    )
                self.assertIsNone(one(after, "host_request"))
                checked = self.repl.execute("ack-check", "handle._reaped, handle.poll().exit_code")
                self.assertEqual(one(checked, "result")["text"], "(True, 0)")

    def test_reused_request_id_does_not_capture_old_cell_bash_completion(self):
        setup = "\n".join(
            [
                "from rlm import bash",
                "import asyncio",
                "reuse_gate = asyncio.Event()",
                "async def launch_after_cell():",
                "    await reuse_gate.wait()",
                "    globals()['reused_handle'] = bash('printf reused-id')",
                "asyncio.create_task(launch_after_cell())",
            ]
        )
        self.repl.execute("reused-cell-id", setup)

        self.repl.send(
            {
                "type": "execute",
                "id": "reused-cell-id",
                "code": "reuse_gate.set()\nawait asyncio.sleep(0.2)",
            }
        )
        request = None
        while True:
            event = self.repl.read_event()
            if event.get("event") == "host_request":
                request = event
                break
            self.assertFalse(event.get("event") == "done" and event.get("id") == "reused-cell-id")
        self.assertEqual(request["data"]["type"], "bash.completed")
        self.assertEqual(request["data"]["command"], "printf reused-id")
        reply_ok(self.repl, request)
        self.assertEqual(one(self.repl.until_done("reused-cell-id"), "done")["status"], "ok")

    def test_protocol_framing_under_noise(self):
        setup = "\n".join(
            [
                "import os, threading",
                "stop = threading.Event()",
                "def spam():",
                "    while not stop.is_set():",
                "        os.write(1, b'noise-' * 64 + b'\\n')",
                "threading.Thread(target=spam, daemon=True).start()",
            ]
        )
        self.assertEqual(one(self.repl.execute("n0", setup), "done")["status"], "ok")
        for i in range(5):
            events = self.repl.execute(f"n{i + 1}", f"{i} * 10")
            self.assertEqual(one(events, "result")["text"], str(i * 10))
        self.repl.execute("n-stop", "stop.set()")
        # Every protocol line parsed as JSON (until_done would have raised
        # otherwise); noise text only ever arrived inside stdout events.
        for line in self.repl.raw_lines:
            event = json.loads(line)
            if "noise-" in line:
                self.assertEqual(event["event"], "stdout")

    def test_malformed_request_line(self):
        self.repl.send_raw("{not json")
        event = self.repl.read_event()
        self.assertEqual(event["event"], "error")
        self.assertEqual(event["ename"], "ProtocolError")
        self.assertIsNone(event["id"])
        events = self.repl.execute("ok", "'alive'")
        self.assertEqual(one(events, "result")["text"], "'alive'")

    def test_list_names(self):
        self.repl.execute("ln1", "alpha = 1\ndef helper(n):\n    return n\n_hidden = 2\nrlm = object()")
        self.repl.send({"type": "list_names", "id": "ln2"})
        done = one(self.repl.until_done("ln2"), "done")
        self.assertEqual(done["status"], "ok")
        self.assertIn("alpha", done["names"])
        self.assertIn("helper", done["names"])
        self.assertNotIn("_hidden", done["names"])
        self.assertNotIn("rlm", done["names"])
        self.assertEqual(done["names"], sorted(done["names"]))

    def test_mcp_status_without_servers(self):
        self.repl.send({"type": "mcp_status", "id": "ms1", "servers": []})
        done = one(self.repl.until_done("ms1"), "done")
        self.assertEqual(done["status"], "ok")
        self.assertEqual(done["connections"], [])

    def test_mcp_status_requires_a_server_list(self):
        self.repl.send({"type": "mcp_status", "id": "ms2", "servers": "fixture-echo"})
        events = self.repl.until_done("ms2")
        self.assertEqual(one(events, "done")["status"], "error")
        self.assertIn("mcp_status", one(events, "error")["evalue"])
        events = self.repl.execute("ms3", "'alive'")
        self.assertEqual(one(events, "result")["text"], "'alive'")

    def test_list_names_skips_non_string_keys(self):
        self.repl.execute("lnk1", "globals()[1] = 1\nbeta = 2")
        self.repl.send({"type": "list_names", "id": "lnk2"})
        done = one(self.repl.until_done("lnk2"), "done")
        self.assertEqual(done["status"], "ok")
        self.assertIn("beta", done["names"])
        self.assertNotIn(1, done["names"])
        events = self.repl.execute("lnk3", "'alive'")
        self.assertEqual(one(events, "result")["text"], "'alive'")

    def test_host_request_round_trip(self):
        code = "\n".join(
            [
                "from rlm.repl import host_request",
                "reply = await host_request({'type': 'demo', 'value': 7})",
                "reply",
            ]
        )
        self.repl.send({"type": "execute", "id": "hr", "code": code})
        request = self.repl.read_event()
        while request.get("event") != "host_request":
            request = self.repl.read_event()
        self.assertEqual(request["data"], {"type": "demo", "value": 7})
        envelope = {"status": "ok", "result": {"status": "weird", "answer": 42}}
        self.repl.send({"type": "host_reply", "id": request["id"], "data": envelope})
        events = self.repl.until_done("hr")
        self.assertEqual(one(events, "result")["text"], repr(envelope))
        self.assertEqual(one(events, "done")["status"], "ok")

    def test_typed_host_request_unwraps_exact_handler_result(self):
        code = "\n".join(
            [
                "from rlm import host_request",
                "reply = await host_request('demo')",
                "reply",
            ]
        )
        self.repl.send({"type": "execute", "id": "typed-hr", "code": code})
        request = self.repl.read_event()
        while request.get("event") != "host_request":
            request = self.repl.read_event()
        handler_result = {"status": "weird", "answer": 42}
        self.repl.send(
            {
                "type": "host_reply",
                "id": request["id"],
                "data": {"status": "ok", "result": handler_result},
            }
        )
        events = self.repl.until_done("typed-hr")
        self.assertEqual(one(events, "result")["text"], repr(handler_result))
        self.assertEqual(one(events, "done")["status"], "ok")

    def test_typed_host_request_raises_host_error(self):
        code = "from rlm import host_request\nawait host_request('demo')"
        self.repl.send({"type": "execute", "id": "typed-error", "code": code})
        request = self.repl.read_event()
        while request.get("event") != "host_request":
            request = self.repl.read_event()
        self.repl.send(
            {
                "type": "host_reply",
                "id": request["id"],
                "data": {"status": "error", "error": "handler exploded"},
            }
        )
        events = self.repl.until_done("typed-error")
        self.assertEqual(one(events, "error")["ename"], "RuntimeError")
        self.assertEqual(one(events, "error")["evalue"], "handler exploded")
        self.assertEqual(one(events, "done")["status"], "error")

    def test_typed_host_request_rejects_unexpected_envelope_status(self):
        code = "from rlm import host_request\nawait host_request('demo')"
        self.repl.send({"type": "execute", "id": "typed-unexpected", "code": code})
        request = self.repl.read_event()
        while request.get("event") != "host_request":
            request = self.repl.read_event()
        self.repl.send(
            {
                "type": "host_reply",
                "id": request["id"],
                "data": {"status": "partial", "result": {}},
            }
        )
        events = self.repl.until_done("typed-unexpected")
        self.assertEqual(one(events, "error")["ename"], "RuntimeError")
        self.assertEqual(
            one(events, "error")["evalue"],
            "host request demo returned unexpected status: 'partial'",
        )
        self.assertEqual(one(events, "done")["status"], "error")

    def test_host_reply_for_unknown_id_dropped(self):
        self.repl.send({"type": "host_reply", "id": "no-such-request", "data": {"status": "ok"}})
        events = self.repl.execute("ok", "'alive'")
        self.assertEqual(one(events, "result")["text"], "'alive'")

    def test_host_request_cancelled_cell_drops_pending_future(self):
        code = "\n".join(
            [
                "from rlm.repl import host_request",
                "await host_request({'type': 'never-answered'})",
            ]
        )
        self.repl.send({"type": "execute", "id": "hr-cancel", "code": code})
        request = self.repl.read_event()
        while request.get("event") != "host_request":
            request = self.repl.read_event()
        self.repl.send({"type": "interrupt"})
        events = self.repl.until_done("hr-cancel")
        self.assertEqual(one(events, "error")["ename"], "KeyboardInterrupt")
        # A reply arriving after the cancel must be dropped, not crash the runtime.
        self.repl.send({"type": "host_reply", "id": request["id"], "data": {"status": "ok"}})
        follow = self.repl.execute("after-cancel", "8+8")
        self.assertEqual(one(follow, "result")["text"], "16")

    def test_display_from_detached_task_keeps_cell_id(self):
        code = "\n".join(
            [
                "import asyncio",
                "from rlm.repl import emit",
                "async def later():",
                "    await asyncio.sleep(0.2)",
                "    emit({'text/plain': 'late'})",
                "detached = asyncio.create_task(later())",
            ]
        )
        self.assertEqual(one(self.repl.execute("det", code), "done")["status"], "ok")
        self.assertEqual(one(self.repl.execute("idle", "1"), "done")["status"], "ok")
        display = self.repl.read_event()
        while display.get("event") != "display":
            display = self.repl.read_event()
        self.assertEqual(display["id"], "det")
        self.assertEqual(display["data"], {"text/plain": "late"})

    def test_shutdown_clean_exit(self):
        self.assertEqual(self.repl.shutdown(), 0)

    def test_shutdown_after_mcp_import_exits_cleanly(self):
        events = self.repl.execute("mcp-import", "import rlm.mcp")
        self.assertEqual(one(events, "done")["status"], "ok")
        self.assertEqual(self.repl.shutdown(), 0)

    def _start_pending_host_request(self) -> None:
        code = "\n".join(
            [
                "from rlm.repl import host_request",
                "await host_request({'type': 'never-answered'})",
            ]
        )
        self.repl.send({"type": "execute", "id": "hr-pending", "code": code})
        request = self.repl.read_event()
        while request.get("event") != "host_request":
            request = self.repl.read_event()

    def test_owner_death_kills_orphan_kernel(self):
        # A kernel must never outlive its owner process. The owner here is a
        # short-lived wrapper that names itself via the same env var the host
        # always sets (PRIME_AGENT_KERNEL_OWNER_PID); it exits while the kernel
        # keeps an open stdin (the write end is held by this test), so the EOF
        # path cannot be what stops it: only the owner watchdog can.
        with tempfile.TemporaryDirectory() as tmp:
            wrapper = os.path.join(tmp, "owner_wrapper.py")
            with open(wrapper, "w") as fh:
                fh.write(
                    "import os, subprocess, sys\n"
                    "kernel_stdin = int(sys.argv[1])\n"
                    "kernel_env = {**os.environ}\n"
                    "kernel_env['PRIME_AGENT_KERNEL_OWNER_PID'] = str(os.getpid())\n"
                    "kernel_env.pop('PYTHONPATH', None)\n"
                    "proc = subprocess.Popen(\n"
                    "    [sys.executable, '-m', 'rlm.repl'],\n"
                    "    stdin=kernel_stdin,\n"
                    "    stdout=None,\n"
                    "    stderr=subprocess.DEVNULL,\n"
                    "    pass_fds=(kernel_stdin,),\n"
                    "    env=kernel_env,\n"
                    ")\n"
                    "print(proc.pid, flush=True)\n"
                )
            read_fd, write_fd = os.pipe()
            env = {
                **os.environ,
                "PYTHONPATH": SRC + os.pathsep + os.environ.get("PYTHONPATH", ""),
            }
            # Hermeticity: an ambient PRIME_AGENT_KERNEL_OWNER_PID (this test
            # itself may run inside a product kernel) would pin the watchdog
            # to a live host pid instead of the wrapper this test controls.
            env.pop("PRIME_AGENT_KERNEL_OWNER_PID", None)
            owner = subprocess.Popen(
                [sys.executable, wrapper, str(read_fd)],
                stdout=subprocess.PIPE,
                text=True,
                env=env,
                pass_fds=(read_fd,),
            )
            try:
                kernel_pid = int(owner.stdout.readline().strip())
                owner.wait(timeout=10)
                deadline = time.monotonic() + 15.0
                exited = False
                while time.monotonic() < deadline:
                    try:
                        os.kill(kernel_pid, 0)
                    except ProcessLookupError:
                        exited = True
                        break
                    time.sleep(0.2)
                self.assertTrue(exited, "orphan kernel must exit after its owner dies")
            finally:
                os.close(write_fd)
                os.close(read_fd)

    def test_stdin_eof_with_pending_host_request_exits(self):
        self._start_pending_host_request()
        assert self.repl.proc.stdin is not None
        self.repl.proc.stdin.close()
        self.assertEqual(self.repl.proc.wait(timeout=10), 0)

    def test_shutdown_with_pending_host_request_exits(self):
        self._start_pending_host_request()
        self.repl.send({"type": "shutdown", "id": "__shutdown__"})
        events = self.repl.until_done("hr-pending")
        self.assertEqual(one(events, "error")["ename"], "RuntimeError")
        self.repl.until_done("__shutdown__")
        self.assertEqual(self.repl.proc.wait(timeout=10), 0)


    def test_interrupt_with_non_string_id_is_protocol_error(self):
        self.repl.send({"type": "execute", "id": "busy", "code": "import asyncio\nawait asyncio.sleep(0.6)\n'done'"})
        time.sleep(0.2)
        self.repl.send({"type": "interrupt", "id": 123})
        events = self.repl.until_done("busy")
        protocol_errors = [e for e in events if e.get("ename") == "ProtocolError"]
        self.assertEqual(len(protocol_errors), 1)
        self.assertIn("interrupt request id must be a string", protocol_errors[0]["evalue"])
        # The running cell was not interrupted by the malformed request.
        self.assertEqual(one(events, "result")["text"], "'done'")
        self.assertEqual(one(events, "done")["status"], "ok")

    def test_snapshot_rejects_non_boolean_and_non_integer_options(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "kernel-state.json")
            self.repl.execute("v1", "big = b'x' * 100_000")
            self.repl.send(
                {
                    "type": "snapshot",
                    "id": "v2",
                    "path": path,
                    "manifest_path": manifest_path,
                    "max_variable_bytes": 1024,
                    "prune_oversized": "false",
                }
            )
            done = one(self.repl.until_done("v2"), "done")
            self.assertEqual(done["status"], "error")
            self.assertIn("boolean", done["reason"])
            events = self.repl.execute("v3", "'big' in dir()")
            self.assertEqual(one(events, "result")["text"], "True")

            self.repl.send(
                {"type": "snapshot", "id": "v4", "path": path, "manifest_path": manifest_path, "max_bytes": "10"}
            )
            done = one(self.repl.until_done("v4"), "done")
            self.assertEqual(done["status"], "error")
            self.assertIn("max_bytes must be a non-negative integer", done["reason"])

            # An explicit JSON null is present-but-invalid, not "use the default".
            self.repl.send(
                {"type": "snapshot", "id": "v5", "path": path, "manifest_path": manifest_path, "max_bytes": None}
            )
            done = one(self.repl.until_done("v5"), "done")
            self.assertEqual(done["status"], "error")
            self.assertIn("max_bytes must be a non-negative integer", done["reason"])

            self.repl.send(
                {
                    "type": "snapshot",
                    "id": "v6",
                    "path": path,
                    "manifest_path": manifest_path,
                    "max_variable_bytes": None,
                }
            )
            done = one(self.repl.until_done("v6"), "done")
            self.assertEqual(done["status"], "error")
            self.assertIn("max_variable_bytes must be a non-negative integer", done["reason"])

            # A negative cap with prune_oversized would delete every user variable: reject it
            # before the snapshot runs, leaving the namespace untouched.
            self.repl.send(
                {
                    "type": "snapshot",
                    "id": "v7",
                    "path": path,
                    "manifest_path": manifest_path,
                    "max_variable_bytes": -1,
                    "prune_oversized": True,
                }
            )
            done = one(self.repl.until_done("v7"), "done")
            self.assertEqual(done["status"], "error")
            self.assertIn("max_variable_bytes must be a non-negative integer", done["reason"])
            events = self.repl.execute("v8", "'big' in dir()")
            self.assertEqual(one(events, "result")["text"], "True")

    def test_snapshot_rejects_identical_path_and_manifest_path(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            self.repl.send({"type": "snapshot", "id": "sp1", "path": path, "manifest_path": path})
            done = one(self.repl.until_done("sp1"), "done")
            self.assertEqual(done["status"], "error")
            self.assertEqual(done["reason"], "path and manifest_path must differ")
            self.assertFalse(os.path.exists(path))

    def test_exception_with_broken_str_reported_safely(self):
        code = "\n".join(
            [
                "class Broken(Exception):",
                "    def __str__(self):",
                "        raise RuntimeError('nope')",
                "raise Broken()",
            ]
        )
        events = self.repl.execute("brk", code)
        error = one(events, "error")
        self.assertEqual(error["ename"], "Broken")
        self.assertEqual(error["evalue"], "<exception str() failed>")
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-brk", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")

    def test_snapshot_manifest_write_failure_fails_without_pruning(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest_path = os.path.join(tmp, "missing-dir", "kernel-state.json")
            self.repl.execute("m1", "big = b'x' * 100_000")
            self.repl.send(
                {
                    "type": "snapshot",
                    "id": "m2",
                    "path": path,
                    "manifest_path": manifest_path,
                    "max_variable_bytes": 1024,
                    "prune_oversized": True,
                }
            )
            done = one(self.repl.until_done("m2"), "done")
            self.assertEqual(done["status"], "error")
            self.assertTrue(done["reason"].startswith("manifest write failed"))
            events = self.repl.execute("m3", "'big' in dir()")
            self.assertEqual(one(events, "result")["text"], "True")

    def test_closed_stdio_cell_still_completes_and_serves_next(self):
        # Closing sys.stdout/sys.stderr must not kill the serve loop: done still
        # arrives and the runtime keeps serving cells.
        events = self.repl.execute("close-io", "import sys\nsys.stdout.close()\nsys.stderr.close()")
        self.assertEqual(one(events, "done")["status"], "ok")
        follow = self.repl.execute("after-close", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")
        self.assertEqual(one(follow, "done")["status"], "ok")

    def test_compile_crash_reports_error_and_serves_next(self):
        # A compile-phase crash outside SyntaxError/ValueError (RecursionError or
        # MemoryError depending on build) must fail the one cell, not the runtime.
        events = self.repl.execute("deep", "a" + ".b" * 100000)
        self.assertIsNotNone(one(events, "error"))
        self.assertEqual(one(events, "done")["status"], "error")
        follow = self.repl.execute("after-deep", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")
        self.assertEqual(one(follow, "done")["status"], "ok")

    def test_rebound_stdout_without_flush_still_completes(self):
        # Rebinding sys.stdout/sys.stderr to flush-less objects must not kill drain.
        events = self.repl.execute("rebind-io", "import sys\nsys.stdout = None\nsys.stderr = None")
        self.assertEqual(one(events, "done")["status"], "ok")
        follow = self.repl.execute("after-rebind", "1+1")
        self.assertEqual(one(follow, "result")["text"], "2")
        self.assertEqual(one(follow, "done")["status"], "ok")

    def test_closed_fds_reclaimed_by_files_still_completes(self):
        # A cell closing fds 1/2 with open() reclaiming the numbers must not wedge
        # drain: tokens go through a private dup, so done still arrives.
        code = "\n".join(
            [
                "import os",
                "os.close(1)",
                "os.close(2)",
                "a = open(os.devnull, 'w')",
                "b = open(os.devnull, 'w')",
            ]
        )
        events = self.repl.execute("reclaim-fds", code)
        self.assertEqual(one(events, "done")["status"], "ok")
        # print() writes via sys.stdout's own dup, so the event must arrive and drain stays exact.
        follow = self.repl.execute("after-reclaim", "print('hi')")
        self.assertEqual(stream_text(follow, "stdout"), "hi\n")
        self.assertEqual(one(follow, "done")["status"], "ok")

    def test_restore_missing_snapshot_is_ok_with_reason(self):
        with tempfile.TemporaryDirectory() as tmp:
            self.repl.send({"type": "restore", "id": "r0", "path": os.path.join(tmp, "absent.dill")})
            done = one(self.repl.until_done("r0"), "done")
            self.assertEqual(done["status"], "ok")
            self.assertEqual(done["restored"], [])
            self.assertEqual(done["failed"], [])
            self.assertEqual(done["reason"], "snapshot not found")


class FinishRequestTest(unittest.TestCase):
    """In-process checks of the parked-interrupt bookkeeping on request finish."""

    def setUp(self) -> None:
        import rlm.repl as repl_module

        self.repl_module = repl_module
        self.addCleanup(self._reset)

    def _reset(self) -> None:
        self.repl_module._inflight.clear()
        self.repl_module._pending_interrupts["ids"].clear()
        self.repl_module._pending_interrupts["any"] = False
        self.repl_module._finishing_rid = None
        self.repl_module._handoff_interrupted = False
        self.repl_module._sigint_target = None
        self.repl_module._active.update({"task": None, "rid": None, "interrupted": False})

    def test_parked_any_survives_while_another_request_is_inflight(self):
        repl = self.repl_module
        repl._inflight.update({"a", "b"})
        repl._pending_interrupts["any"] = True
        repl._finish_request("a")
        self.assertTrue(repl._pending_interrupts["any"])
        repl._finish_request("b")
        self.assertFalse(repl._pending_interrupts["any"])

    def test_compile_error_consumes_parked_untargeted_interrupt(self):
        # An untargeted interrupt parked while a compile-broken request was
        # inflight belongs to that request: its compile-error finish must
        # consume it even while another request is still inflight, so the
        # interrupt cannot leak onto the next cell.
        repl = self.repl_module
        repl._inflight.update({"bad", "other"})
        repl._pending_interrupts["any"] = True
        asyncio.run(repl._handle_request(repl._handle_execute, {"id": "bad", "code": "def broken(:\n    pass"}, {}))
        self.assertFalse(repl._pending_interrupts["any"])
        self.assertNotIn("bad", repl._inflight)
        self.assertIn("other", repl._inflight)

    def test_post_run_error_leaves_parked_interrupt_for_next_request(self):
        # Once _run_guarded finished a request (_finish_locked already ran), a
        # later exception in the same handler must not consume an untargeted
        # interrupt parked for the still-inflight next request.
        repl = self.repl_module

        async def finished_then_broken(req, ns):
            repl._finish_request(req["id"])  # simulate _run_guarded completion
            repl._pending_interrupts["any"] = True  # parked while "other" is inflight
            raise RuntimeError("post-execution failure")

        repl._inflight.update({"done", "other"})
        asyncio.run(repl._handle_request(finished_then_broken, {"id": "done"}, {}))
        self.assertTrue(repl._pending_interrupts["any"])
        self.assertIn("other", repl._inflight)

    def test_sigint_in_post_run_guarded_window_reports_snapshot_ok(self):
        # A finishing-targeted SIGINT between _run_guarded's return and
        # _finish_request raises KeyboardInterrupt into _handle_state; the
        # completed destructive snapshot must still report done status ok.
        import signal
        from unittest import mock

        repl = self.repl_module
        real_run_guarded = repl._run_guarded

        async def run_guarded_then_sigint(task, rid):
            outcome = await real_run_guarded(task, rid)
            with repl._interrupt_lock:
                repl._sigint_target = rid
            # Synchronous SIGINT in the post-run window: the handler sees
            # _sigint_target == _finishing_rid and raises right here.
            signal.raise_signal(signal.SIGINT)
            return outcome

        previous = signal.signal(signal.SIGINT, repl._sigint_handler)
        self.addCleanup(signal.signal, signal.SIGINT, previous)
        previous_loop = repl._loop
        self.addCleanup(setattr, repl, "_loop", previous_loop)
        sent = []
        ns = {"big": b"x" * 100_000}

        with tempfile.TemporaryDirectory() as tmp:
            req = {
                "type": "snapshot",
                "id": "snap",
                "path": os.path.join(tmp, "kernel-state.dill"),
                "manifest_path": os.path.join(tmp, "kernel-state.json"),
                "max_variable_bytes": 1024,
                "prune_oversized": True,
            }

            async def main():
                repl._loop = asyncio.get_running_loop()
                repl._inflight.add("snap")
                await repl._handle_request(repl._handle_state, req, ns)

            with mock.patch.object(repl, "_run_guarded", run_guarded_then_sigint):
                with mock.patch.object(repl, "_send", sent.append):
                    asyncio.run(main())

        done = next(e for e in sent if e.get("event") == "done")
        self.assertEqual(done["status"], "ok")
        self.assertEqual(done["pruned"], ["big"])
        # The prune ran (destructive success) and the request is fully finished.
        self.assertEqual(ns, {})
        self.assertNotIn("snap", repl._inflight)

    def test_protocol_interrupt_during_restore_commit_is_consumed_and_next_request_runs(self):
        # A protocol interrupt (_request_interrupt -> SIGINT on the main thread)
        # landing while the restore applies its staged names is consumed: the
        # restore reports done ok with every name applied, and a following
        # request runs normally with no interrupt bleed.
        import signal
        from unittest import mock

        repl = self.repl_module
        previous = signal.signal(signal.SIGINT, repl._sigint_handler)
        self.addCleanup(signal.signal, signal.SIGINT, previous)
        previous_loop = repl._loop
        self.addCleanup(setattr, repl, "_loop", previous_loop)
        sent = []

        class InterruptOnFirstSet(dict):
            def __setitem__(self, key, value):
                super().__setitem__(key, value)
                if len(self) == 1:
                    repl._request_interrupt("restore")

        ns = InterruptOnFirstSet()
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest = os.path.join(tmp, "kernel-state.json")
            snap = repl._snapshot_state({"a": 1, "b": 2}, path, manifest, 1 << 20, 1 << 20, False)
            self.assertNotIn("error", snap)

            async def main():
                repl._loop = asyncio.get_running_loop()
                repl._inflight.add("restore")
                await repl._handle_request(repl._handle_state, {"type": "restore", "id": "restore", "path": path}, ns)
                repl._inflight.add("next")
                await repl._handle_request(repl._handle_execute, {"id": "next", "code": "checked = 1 + 1"}, {})

            with mock.patch.object(repl, "_send", sent.append):
                with mock.patch.object(repl, "_drain_output", lambda: None):
                    asyncio.run(main())

        done_restore = next(e for e in sent if e.get("event") == "done" and e["id"] == "restore")
        self.assertEqual(done_restore["status"], "ok")
        self.assertEqual(done_restore["restored"], ["a", "b"])
        self.assertEqual(dict(ns), {"a": 1, "b": 2})
        done_next = next(e for e in sent if e.get("event") == "done" and e["id"] == "next")
        self.assertEqual(done_next["status"], "ok")
        self.assertIsNone(repl._sigint_target)
        self.assertFalse(repl._pending_interrupts["any"])
        self.assertFalse(repl._pending_interrupts["ids"])

    @staticmethod
    def _run_resuming(coro):
        # Mimic main(): a KI escaping a task stops run_until_complete; the
        # runtime resumes the loop and serving continues.
        loop = asyncio.new_event_loop()
        try:
            outer = loop.create_task(coro)
            while not outer.done():
                try:
                    loop.run_until_complete(outer)
                except KeyboardInterrupt:
                    continue
        finally:
            loop.close()

    def test_protocol_interrupt_after_restore_returned_before_task_done_reports_ok(self):
        # The interrupt raises into the state task AFTER _restore_state returned
        # but before the task completes; every binding is committed, so the
        # request must report ok from the committed box, not interrupted.
        import signal
        from unittest import mock

        repl = self.repl_module
        previous = signal.signal(signal.SIGINT, repl._sigint_handler)
        self.addCleanup(signal.signal, signal.SIGINT, previous)
        previous_loop = repl._loop
        self.addCleanup(setattr, repl, "_loop", previous_loop)
        sent = []
        real_restore = repl._restore_state

        def restore_then_interrupt(*args, **kwargs):
            result = real_restore(*args, **kwargs)
            repl._sigint_target = "restore"
            repl._sigint_handler(signal.SIGINT, None)  # raises into the still-running task
            return result

        ns: dict = {}
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest = os.path.join(tmp, "kernel-state.json")
            snap = repl._snapshot_state({"a": 1, "b": 2}, path, manifest, 1 << 20, 1 << 20, False)
            self.assertNotIn("error", snap)

            async def main():
                repl._loop = asyncio.get_running_loop()
                repl._inflight.add("restore")
                await repl._handle_request(repl._handle_state, {"type": "restore", "id": "restore", "path": path}, ns)
                repl._inflight.add("next")
                await repl._handle_request(repl._handle_execute, {"id": "next", "code": "checked = 1 + 1"}, {})

            with mock.patch.object(repl, "_restore_state", restore_then_interrupt):
                with mock.patch.object(repl, "_send", sent.append):
                    with mock.patch.object(repl, "_drain_output", lambda: None):
                        self._run_resuming(main())

        done_restore = next(e for e in sent if e.get("event") == "done" and e["id"] == "restore")
        self.assertEqual(done_restore["status"], "ok")
        self.assertEqual(done_restore["restored"], ["a", "b"])
        self.assertEqual(ns, {"a": 1, "b": 2})
        done_next = next(e for e in sent if e.get("event") == "done" and e["id"] == "next")
        self.assertEqual(done_next["status"], "ok")
        self.assertIsNone(repl._sigint_target)
        self.assertFalse(repl._pending_interrupts["any"])
        self.assertFalse(repl._pending_interrupts["ids"])

    def test_nonprotocol_keyboardinterrupt_after_committed_restore_is_not_recovered(self):
        # A user-originated KeyboardInterrupt (no _sigint_handler provenance:
        # _active["interrupted"] stays False) after the restore committed must
        # keep the interrupted error, not be converted to snapshot success.
        from unittest import mock

        repl = self.repl_module
        previous_loop = repl._loop
        self.addCleanup(setattr, repl, "_loop", previous_loop)
        sent = []
        real_restore = repl._restore_state

        def restore_then_user_interrupt(*args, **kwargs):
            real_restore(*args, **kwargs)  # fills the committed box
            raise KeyboardInterrupt("nonprotocol")

        ns: dict = {}
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")
            manifest = os.path.join(tmp, "kernel-state.json")
            snap = repl._snapshot_state({"a": 1, "b": 2}, path, manifest, 1 << 20, 1 << 20, False)
            self.assertNotIn("error", snap)

            async def main():
                repl._loop = asyncio.get_running_loop()
                repl._inflight.add("restore")
                await repl._handle_request(repl._handle_state, {"type": "restore", "id": "restore", "path": path}, ns)

            with mock.patch.object(repl, "_restore_state", restore_then_user_interrupt):
                with mock.patch.object(repl, "_send", sent.append):
                    with mock.patch.object(repl, "_drain_output", lambda: None):
                        self._run_resuming(main())

        done = next(e for e in sent if e.get("event") == "done" and e["id"] == "restore")
        self.assertEqual(done["status"], "error")
        self.assertEqual(done["reason"], "interrupted")

    def test_protocol_interrupt_after_destructive_snapshot_returned_reports_ok(self):
        # Same post-return window for snapshot: the pruning commit already ran,
        # so the interrupt must not misreport the destructive snapshot as failed.
        import signal
        from unittest import mock

        repl = self.repl_module
        previous = signal.signal(signal.SIGINT, repl._sigint_handler)
        self.addCleanup(signal.signal, signal.SIGINT, previous)
        previous_loop = repl._loop
        self.addCleanup(setattr, repl, "_loop", previous_loop)
        sent = []
        real_snapshot = repl._snapshot_state

        def snapshot_then_interrupt(*args, **kwargs):
            result = real_snapshot(*args, **kwargs)
            repl._sigint_target = "snap"
            repl._sigint_handler(signal.SIGINT, None)  # raises into the still-running task
            return result

        ns = {"small": 1, "big": "x" * 100000}
        with tempfile.TemporaryDirectory() as tmp:
            req = {
                "type": "snapshot",
                "id": "snap",
                "path": os.path.join(tmp, "kernel-state.dill"),
                "manifest_path": os.path.join(tmp, "kernel-state.json"),
                "prune_oversized": True,
                "max_variable_bytes": 1024,
            }

            async def main():
                repl._loop = asyncio.get_running_loop()
                repl._inflight.add("snap")
                await repl._handle_request(repl._handle_state, req, ns)

            with mock.patch.object(repl, "_snapshot_state", snapshot_then_interrupt):
                with mock.patch.object(repl, "_send", sent.append):
                    self._run_resuming(main())

        done = next(e for e in sent if e.get("event") == "done" and e["id"] == "snap")
        self.assertEqual(done["status"], "ok")
        self.assertEqual(done["saved"], ["small"])
        self.assertEqual(done["pruned"], ["big"])
        self.assertEqual(ns, {"small": 1})
        self.assertIsNone(repl._sigint_target)

    def test_untargeted_interrupt_in_done_task_handoff_is_not_parked(self):
        # The cell task is done but _run_guarded's finally has not run yet
        # (_active still names the rid, _finishing_rid is unset). An untargeted
        # interrupt in that handoff belongs to THIS request: it must be recorded
        # for its finishing phase, never parked where the next request eats it.
        import signal

        repl = self.repl_module

        class DoneTask:
            def done(self):
                return True

            def cancel(self):
                raise AssertionError("a done task must not be cancelled")

        repl._inflight.update({"handoff", "other"})
        repl._active.update({"task": DoneTask(), "rid": "handoff", "interrupted": False})
        previous = signal.signal(signal.SIGINT, repl._sigint_handler)
        self.addCleanup(signal.signal, signal.SIGINT, previous)
        repl._request_interrupt(None)
        deadline = time.monotonic() + 5
        while not repl._handoff_interrupted and time.monotonic() < deadline:
            time.sleep(0.01)
        self.assertEqual(repl._sigint_target, "handoff")
        self.assertFalse(repl._pending_interrupts["any"])
        self.assertTrue(repl._consume_handoff_interrupt())
        self.assertFalse(repl._handoff_interrupted)
        self.assertIn("other", repl._inflight)


class SnapshotPruneShieldTest(unittest.TestCase):
    """The prune-deletion window must not be split by a SIGINT-raised KeyboardInterrupt."""

    def test_sigint_mid_prune_is_consumed_after_all_deletions_ran(self):
        import signal

        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        from rlm.repl import _snapshot_state

        class SigintOnFirstPop(dict):
            fired = False

            def pop(self, key, default=None):
                if not self.fired:
                    self.fired = True
                    # Synchronous SIGINT on the main thread: lands exactly mid-loop.
                    signal.raise_signal(signal.SIGINT)
                return super().pop(key, default)

        ns = SigintOnFirstPop(big1=b"x" * 100_000, big2=b"y" * 100_000)
        with tempfile.TemporaryDirectory() as tmp:
            result = _snapshot_state(
                ns,
                os.path.join(tmp, "kernel-state.dill"),
                os.path.join(tmp, "kernel-state.json"),
                max_bytes=1 << 20,
                max_variable_bytes=1024,
                prune_oversized=True,
            )
        # The parked SIGINT is consumed: the committed snapshot reports success.
        self.assertEqual(result["pruned"], ["big1", "big2"])
        self.assertNotIn("error", result)
        # Both deletions ran: ns matches the manifest.
        self.assertEqual(dict(ns), {})

    def test_sigint_after_manifest_commit_before_deletions_is_consumed(self):
        import signal
        from unittest import mock

        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        from rlm.repl import _snapshot_state

        real_replace = os.replace

        ns = {"big1": b"x" * 100_000, "big2": b"y" * 100_000}
        with tempfile.TemporaryDirectory() as tmp:
            manifest_path = os.path.join(tmp, "kernel-state.json")

            def replace_then_sigint(src, dst):
                real_replace(src, dst)
                # Synchronous SIGINT right after the manifest commit, before any deletion.
                if dst == manifest_path:
                    signal.raise_signal(signal.SIGINT)

            with mock.patch("os.replace", replace_then_sigint):
                result = _snapshot_state(
                    ns,
                    os.path.join(tmp, "kernel-state.dill"),
                    manifest_path,
                    max_bytes=1 << 20,
                    max_variable_bytes=1024,
                    prune_oversized=True,
                )
            # The parked SIGINT is consumed: the committed destructive snapshot
            # reports success instead of surfacing KeyboardInterrupt.
            self.assertEqual(result["pruned"], ["big1", "big2"])
            self.assertNotIn("error", result)
            # The deletions still ran: ns is consistent with the committed manifest.
            self.assertEqual(ns, {})
            with open(manifest_path) as fh:
                self.assertEqual(json.load(fh)["pruned"], ["big1", "big2"])


class RestoreApplyShieldTest(unittest.TestCase):
    """The restore assignment loop must not be split by a SIGINT-raised KeyboardInterrupt."""

    def _write_snapshot(self, tmp: str, source: dict[str, object]) -> str:
        path = os.path.join(tmp, "kernel-state.dill")
        from rlm.repl import _snapshot_state

        result = _snapshot_state(
            source,
            path,
            os.path.join(tmp, "kernel-state.json"),
            max_bytes=1 << 20,
            max_variable_bytes=1 << 20,
            prune_oversized=False,
        )
        self.assertNotIn("error", result)
        return path

    def setUp(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)

    class SigintOnNthSet(dict):
        """Fires one synchronous SIGINT right after its Nth assignment."""

        def __init__(self, fire_on: int) -> None:
            super().__init__()
            self.fire_on = fire_on
            self.calls = 0

        def __setitem__(self, key, value):
            super().__setitem__(key, value)
            self.calls += 1
            if self.calls == self.fire_on:
                signal.raise_signal(signal.SIGINT)

    def test_sigint_during_staging_leaves_namespace_unchanged(self):
        from rlm import repl as repl_module
        from rlm.repl import _restore_state

        calls = {"n": 0}

        real_unpickler = repl_module._snapshot_unpickler

        def unpickler_then_sigint(dill):
            guarded = real_unpickler(dill)

            class SigintOnSecondLoad(guarded):
                def load(self):
                    calls["n"] += 1
                    if calls["n"] == 2:
                        # Synchronous SIGINT mid-deserialize: nothing may have touched ns yet.
                        signal.raise_signal(signal.SIGINT)
                    return super().load()

            return SigintOnSecondLoad

        with tempfile.TemporaryDirectory() as tmp:
            path = self._write_snapshot(tmp, {"a": 1, "b": 2})
            ns = {"a": "old", "unrelated": "keep"}
            with mock.patch.object(repl_module, "_snapshot_unpickler", unpickler_then_sigint):
                with self.assertRaises(KeyboardInterrupt):
                    _restore_state(ns, path)
        # The old namespace is byte-identical: no partial old/new mixture.
        self.assertEqual(ns, {"a": "old", "unrelated": "keep"})

    def test_sigint_mid_apply_is_consumed_and_all_names_applied(self):
        from rlm.repl import _restore_state

        with tempfile.TemporaryDirectory() as tmp:
            path = self._write_snapshot(tmp, {"a": 1, "b": 2})
            ns = self.SigintOnNthSet(fire_on=1)
            result = _restore_state(ns, path)
        # The parked SIGINT is consumed: the committed restore reports success.
        self.assertNotIn("error", result)
        self.assertEqual(result["restored"], ["a", "b"])
        self.assertEqual(dict(ns), {"a": 1, "b": 2})

    def test_sigint_after_last_apply_is_consumed(self):
        from rlm.repl import _restore_state

        with tempfile.TemporaryDirectory() as tmp:
            path = self._write_snapshot(tmp, {"a": 1, "b": 2})
            ns = self.SigintOnNthSet(fire_on=2)
            result = _restore_state(ns, path)
        self.assertNotIn("error", result)
        self.assertEqual(result["restored"], ["a", "b"])
        self.assertEqual(dict(ns), {"a": 1, "b": 2})

    def test_sigint_with_backfill_first_write_is_consumed(self):
        from rlm.repl import _restore_state

        exec("SECRET = 42\ndef reader():\n    return SECRET", source := {"__name__": "__main__"})
        with tempfile.TemporaryDirectory() as tmp:
            ns = self.SigintOnNthSet(fire_on=1)
            result = _restore_state(ns, self._write_snapshot(tmp, {"reader": source["reader"]}))
        self.assertEqual((result["restored"], ns["SECRET"]), (["reader"], 42))

    def _restore_with_sigint_at_unpark(self):
        """Real unparking swap, then the newly restored handler fires immediately."""
        from rlm.repl import _restore_state

        real_signal = signal.signal
        state = {"calls": 0, "fired": False}

        def swap_then_fire(sig, handler):
            prev = real_signal(sig, handler)
            state["calls"] += 1
            if state["calls"] == 2:
                # A SIGINT delivered while parked but first seen after the swap
                # runs the restored raising handler inside _restore_state's tail.
                state["fired"] = True
                handler(sig, None)
            return prev

        committed: list = []
        with tempfile.TemporaryDirectory() as tmp:
            path = self._write_snapshot(tmp, {"a": 1, "b": 2})
            ns: dict = {}
            with mock.patch("signal.signal", swap_then_fire):
                with self.assertRaises(KeyboardInterrupt):
                    _restore_state(ns, path, committed)
        self.assertTrue(state["fired"])
        return committed, ns

    def test_sigint_at_handler_restoration_publishes_committed_result(self):
        # Every binding is applied by unpark time: the KeyboardInterrupt escapes
        # this frame, but the filled box lets _handle_state report success.
        previous = signal.signal(signal.SIGINT, signal.default_int_handler)
        self.addCleanup(signal.signal, signal.SIGINT, previous)
        committed, ns = self._restore_with_sigint_at_unpark()
        self.assertEqual(committed[0]["restored"], ["a", "b"])
        self.assertEqual(ns, {"a": 1, "b": 2})
        self.assertIs(signal.getsignal(signal.SIGINT), signal.default_int_handler)

    def test_sigint_at_handler_restoration_with_non_default_prior_handler(self):
        fired = []

        def prior(signum, frame):
            fired.append(signum)
            raise KeyboardInterrupt

        previous = signal.signal(signal.SIGINT, prior)
        self.addCleanup(signal.signal, signal.SIGINT, previous)
        committed, ns = self._restore_with_sigint_at_unpark()
        self.assertEqual(committed[0]["restored"], ["a", "b"])
        self.assertEqual(ns, {"a": 1, "b": 2})
        self.assertEqual(fired, [signal.SIGINT])
        self.assertIs(signal.getsignal(signal.SIGINT), prior)

    def test_handler_restored_and_no_interrupt_bleed(self):
        from rlm.repl import _restore_state

        original = signal.getsignal(signal.SIGINT)
        with tempfile.TemporaryDirectory() as tmp:
            path = self._write_snapshot(tmp, {"a": 1, "b": 2})
            ns = self.SigintOnNthSet(fire_on=1)
            result = _restore_state(ns, path)
        self.assertNotIn("error", result)
        self.assertIs(signal.getsignal(signal.SIGINT), original)
        # Nothing parked bleeds into later work: a fresh SIGINT raises normally.
        with self.assertRaises(KeyboardInterrupt):
            signal.raise_signal(signal.SIGINT)


class SnapshotTempCleanupTest(unittest.TestCase):
    def test_keyboard_interrupt_during_payload_write_removes_temp_file(self):
        from unittest import mock as unittest_mock

        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        import dill

        from rlm.repl import _snapshot_state

        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "kernel-state.dill")

            real_dump = dill.dump

            def interrupted_dump(value, fh):
                # Interrupt mid-dump, after partial bytes landed in the staged temp.
                fh.write(b"partial")
                raise KeyboardInterrupt

            with unittest_mock.patch.object(dill, "dump", interrupted_dump):
                with self.assertRaises(KeyboardInterrupt):
                    _snapshot_state(
                        {"x": 1},
                        path,
                        os.path.join(tmp, "manifest.json"),
                        max_bytes=1 << 20,
                        max_variable_bytes=1 << 20,
                        prune_oversized=False,
                    )
            self.assertEqual(os.listdir(tmp), [])  # no temp (or final) files survive

    def test_name_deleted_by_background_thread_mid_snapshot_is_skipped(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        from rlm.repl import _snapshot_state

        class RacyNs(dict):
            # Simulates a background thread deleting "gone" between the key
            # listing and the per-name lookup.
            def keys(self):
                yield from ("gone", "kept")

        ns = RacyNs(kept=1)
        with tempfile.TemporaryDirectory() as tmp:
            result = _snapshot_state(
                ns,
                os.path.join(tmp, "kernel-state.dill"),
                os.path.join(tmp, "manifest.json"),
                max_bytes=1 << 20,
                max_variable_bytes=1 << 20,
                prune_oversized=False,
            )
        self.assertNotIn("error", result)
        self.assertEqual(result["saved"], ["kept"])
        self.assertEqual(result["skipped"], [{"name": "gone", "reason": "deleted during snapshot"}])



class SnapshotRestoreBoundsTest(unittest.TestCase):
    """The restore's record reader enforces the writer's own byte caps: a
    sparse multi-gigabyte snapshot file cannot OOM the process (Macroscope
    PR #2744 HIGH repl.py:731), and a failed revival merges no backfill
    (Macroscope PR #2744 MED repl.py:1077)."""

    def setUp(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        from rlm import repl as repl_module

        self.repl_module = repl_module
        tmp = tempfile.TemporaryDirectory()
        self.addCleanup(tmp.cleanup)
        self.dir = tmp.name

    def _frame(self, name: bytes, blob: bytes) -> bytes:
        return (
            len(name).to_bytes(4, "little")
            + name
            + len(blob).to_bytes(8, "little")
            + blob
        )

    def test_oversized_record_declared_length_is_capped_before_reading(self):
        import dill

        magic = self.repl_module._SNAPSHOT_MAGIC
        # A sparse file whose APPARENT size covers a declared 2 GiB record:
        # the file-size bounds check alone would pass it (the allocation is
        # the attack), so the per-record cap must reject it first.
        huge_len = 2 * 1024 * 1024 * 1024
        path = os.path.join(self.dir, "sparse-state.dill")
        with open(path, "wb") as fh:
            fh.write(magic)
            fh.write(self._frame(b"victim", dill.dumps(b"x")))
        # Truncate-declare: append the header of a huge record, then make the
        # file's apparent size cover it (a sparse file: no real bytes).
        with open(path, "ab") as fh:
            fh.write((4).to_bytes(4, "little"))
            fh.write(b"huge")
            fh.write(huge_len.to_bytes(8, "little"))
            fh.truncate(fh.tell() + huge_len)
        with open(path, "rb") as fh:
            with self.assertRaises(ValueError):
                self.repl_module._read_snapshot_records(fh, 256 * 1024 * 1024, 16 * 1024 * 1024)

    def test_oversized_declared_record_name_is_capped_before_reading(self):
        """A corrupt or sparse snapshot declaring a multi-gigabyte RECORD NAME must
        fail the aggregate cap BEFORE fh.read(name_len) allocates it (the same OOM
        class the blob caps close; Macroscope PR #2744 HIGH repl.py:729)."""
        import dill

        magic = self.repl_module._SNAPSHOT_MAGIC
        huge_len = 2 * 1024 * 1024 * 1024
        path = os.path.join(self.dir, "sparse-name-state.dill")
        with open(path, "wb") as fh:
            fh.write(magic)
            # A valid first record the reader must survive past.
            fh.write(self._frame(b"ok", dill.dumps(b"x")))
            # Then the huge-name header, with the file's APPARENT size made to
            # cover it (a sparse file: no real bytes, so the size check alone
            # passes it — the cap must reject first).
            fh.write(huge_len.to_bytes(4, "little"))
            # The file's APPARENT size must cover the declared name PLUS the
            # 8-byte blob-length field that follows it, so the pre-existing
            # truncated-record size check passes and the NAME cap is the
            # guard that actually fires.
            fh.truncate(fh.tell() + huge_len + 8)
        with open(path, "rb") as fh:
            with self.assertRaises(ValueError):
                self.repl_module._read_snapshot_records(fh, 256 * 1024 * 1024, 16 * 1024 * 1024)

    def test_failed_revival_merges_no_backfill(self):
        import dill

        path = os.path.join(self.dir, "state.dill")
        records = self._frame(b"good", dill.dumps("ok")) + self._frame(b"bad", dill.dumps("BAD"))
        with open(path, "wb") as fh:
            fh.write(self.repl_module._SNAPSHOT_MAGIC)
            fh.write(records)
        ns = {"keep": 0}
        real_revive = self.repl_module._revive_with_live_globals
        state = {"revived": 0}

        def revive(value, live_ns, backfill):
            if value == "BAD":
                # The buggy shape appended to the shared backfill BEFORE the
                # revival completed: a failed name still merged its globals.
                backfill.append(("leaked_from_bad", 42))
                raise RuntimeError("revival boom")
            backfill.append(("good_global", 1))
            state["revived"] += 1
            return value

        self.repl_module._revive_with_live_globals = revive
        try:
            result = self.repl_module._restore_state(
                ns, path, max_bytes=1 << 20, max_variable_bytes=1 << 20
            )
        finally:
            self.repl_module._revive_with_live_globals = real_revive
        self.assertIn("good", result["restored"])
        self.assertIn("good_global", ns)
        self.assertNotIn("leaked_from_bad", ns, "a failed revival must merge nothing")
        self.assertEqual(
            [entry["name"] for entry in result["failed"]],
            ["bad"],
        )
        self.assertEqual(ns["good"], "ok")


class SnapshotPairConsistencyTest(unittest.TestCase):
    # Direct fault injection into _snapshot_state: portable and deterministic
    # (chmod-based injection breaks as root and has different Windows semantics).
    def setUp(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        from rlm.repl import _snapshot_state

        self.snapshot = _snapshot_state
        tmp = tempfile.TemporaryDirectory()
        self.addCleanup(tmp.cleanup)
        self.dir = tmp.name
        self.path = os.path.join(self.dir, "kernel-state.dill")
        self.manifest_path = os.path.join(self.dir, "kernel-state.json")

    def _snap(self, ns, path=None, manifest_path=None, **kw):
        args = dict(max_bytes=1 << 20, max_variable_bytes=1 << 20, prune_oversized=False)
        args.update(kw)
        return self.snapshot(ns, path or self.path, manifest_path or self.manifest_path, **args)

    def _old_pair(self, path=None, manifest_path=None):
        self.assertNotIn("error", self._snap({"keep": 1}, path, manifest_path))
        with open(path or self.path, "rb") as fh:
            payload = fh.read()
        with open(manifest_path or self.manifest_path, "rb") as fh:
            manifest = fh.read()
        return payload, manifest

    def _assert_pair(self, old_payload, old_manifest, path=None, manifest_path=None):
        with open(path or self.path, "rb") as fh:
            self.assertEqual(fh.read(), old_payload)
        with open(manifest_path or self.manifest_path, "rb") as fh:
            self.assertEqual(fh.read(), old_manifest)

    def _assert_only_pair_files(self, directory=None):
        self.assertEqual(
            sorted(os.listdir(directory or self.dir)),
            ["kernel-state.dill", "kernel-state.json"],
        )

    def test_complete_payload_respects_aggregate_size_cap(self):
        name = "x" * 10_000
        result = self._snap({name: 1}, max_bytes=128, max_variable_bytes=128)
        self.assertEqual(result["saved"], [])
        self.assertEqual(result["skipped"], [{"name": name, "reason": "exceeds aggregate snapshot size cap"}])
        self.assertLessEqual(result["bytes"], 128)
        self._assert_only_pair_files()

    def test_near_cap_payload_skips_tail_instead_of_failing_snapshot(self):
        import dill

        from rlm.repl import _SNAPSHOT_MAGIC, _restore_state

        dill.settings["recurse"] = True
        source = {"a": "first", "b": "second"}
        blobs = {name: dill.dumps(value) for name, value in source.items()}
        # One byte short of the full single-pass payload (magic + both records),
        # so "a" fits exactly and "b" overflows the remaining aggregate budget.
        cap = len(_SNAPSHOT_MAGIC) + 13 + len(blobs["a"]) + 13 + len(blobs["b"]) - 1

        result = self._snap(source, max_bytes=cap, max_variable_bytes=cap)
        self.assertEqual(result["saved"], ["a"])
        self.assertEqual(result["skipped"], [{"name": "b", "reason": "exceeds aggregate snapshot size cap"}])
        self.assertLessEqual(result["bytes"], cap)
        ns: dict = {}
        self.assertNotIn("error", _restore_state(ns, self.path))
        self.assertEqual(ns, {"a": "first"})

    def test_zero_size_cap_writes_no_empty_payload_overhead(self):
        result = self._snap({}, max_bytes=0, max_variable_bytes=0)
        self.assertEqual(result, {"error": "write failed: snapshot exceeds aggregate snapshot size cap"})
        self.assertEqual(os.listdir(self.dir), [])

    def test_manifest_write_failure_preserves_prior_pair(self):
        old_payload, old_manifest = self._old_pair()
        ns = {"keep": 1, "big": b"x" * 100_000}
        with mock.patch("json.dump", side_effect=OSError("disk full")):
            result = self._snap(ns, max_variable_bytes=1024, prune_oversized=True)
        self.assertTrue(result["error"].startswith("manifest write failed"))
        self._assert_pair(old_payload, old_manifest)
        self._assert_only_pair_files()
        self.assertIn("big", ns)  # not pruned

    def test_payload_replace_failure_preserves_prior_pair(self):
        old_payload, old_manifest = self._old_pair()
        real_replace = os.replace

        def failing_replace(src, dst):
            if dst == self.path:
                raise OSError("rename failed")
            return real_replace(src, dst)

        with mock.patch("os.replace", failing_replace):
            result = self._snap({"keep": 2})
        self.assertTrue(result["error"].startswith("write failed"))
        self._assert_pair(old_payload, old_manifest)
        self._assert_only_pair_files()

    def test_payload_write_failure_returns_error_dict_and_cleans_temp(self):
        old_payload, old_manifest = self._old_pair()
        real_fdopen = os.fdopen

        class FailingWrite:
            def __init__(self, fh):
                self.fh = fh

            def __enter__(self):
                return self

            def __exit__(self, *args):
                self.fh.close()

            def write(self, data):
                raise OSError("disk full")

        def fdopen(fd, mode):
            fh = real_fdopen(fd, mode)
            return FailingWrite(fh) if mode == "wb" else fh

        with mock.patch("os.fdopen", side_effect=fdopen):
            result = self._snap({"keep": 2})
        self.assertTrue(result["error"].startswith("write failed"))
        self._assert_pair(old_payload, old_manifest)
        self._assert_only_pair_files()

    def test_keyboard_interrupt_between_stages_cleans_temps(self):
        old_payload, old_manifest = self._old_pair()
        with mock.patch("json.dump", side_effect=KeyboardInterrupt):
            with self.assertRaises(KeyboardInterrupt):
                self._snap({"keep": 2})
        self._assert_pair(old_payload, old_manifest)
        self._assert_only_pair_files()

    def test_sigint_after_payload_replace_is_parked_and_consumed(self):
        # SIGINT is parked from before the payload replace through the deletions.
        real_replace = os.replace
        ns = {"keep": 1, "big": b"x" * 100_000}

        def replace_then_sigint(src, dst):
            real_replace(src, dst)
            if dst == self.path:
                signal.raise_signal(signal.SIGINT)

        with mock.patch("os.replace", replace_then_sigint):
            result = self._snap(ns, max_variable_bytes=1024, prune_oversized=True)
        self.assertNotIn("error", result)
        self.assertEqual(result["pruned"], ["big"])
        self.assertNotIn("big", ns)  # the prune still ran; the SIGINT was consumed
        self._assert_only_pair_files()
        with open(self.manifest_path) as fh:
            self.assertEqual(json.load(fh)["pruned"], ["big"])

    def test_signal_install_failure_propagates_and_cleans_temps(self):
        # A SIGINT-handler install failure (e.g. off-main-thread) must not leak temps.
        old_payload, old_manifest = self._old_pair()
        with mock.patch("signal.signal", side_effect=ValueError("main thread only")):
            with self.assertRaises(ValueError):
                self._snap({"keep": 2})
        self._assert_pair(old_payload, old_manifest)
        self._assert_only_pair_files()

    def test_fdopen_failure_closes_raw_fd_and_removes_temp(self):
        old_payload, old_manifest = self._old_pair()
        real_mkstemp = tempfile.mkstemp
        seen = {}

        def spy_mkstemp(**kwargs):
            seen["fd"], seen["name"] = real_mkstemp(**kwargs)
            return seen["fd"], seen["name"]

        with mock.patch("tempfile.mkstemp", spy_mkstemp):
            with mock.patch("os.fdopen", side_effect=OSError("bad fd")):
                result = self._snap({"keep": 2})
        self.assertTrue(result["error"].startswith("write failed"))
        with self.assertRaises(OSError):
            os.fstat(seen["fd"])  # the raw mkstemp fd was closed
        self.assertFalse(os.path.exists(seen["name"]))
        self._assert_pair(old_payload, old_manifest)
        self._assert_only_pair_files()

    def test_manifest_replace_failure_leaves_new_payload_old_manifest(self):
        # The documented unavoidable failure state between the two renames.
        old_payload, old_manifest = self._old_pair()
        ns = {"keep": 2, "big": b"x" * 100_000}
        real_replace = os.replace

        def failing_manifest_replace(src, dst):
            if dst == self.manifest_path:
                raise OSError("rename failed")
            return real_replace(src, dst)

        with mock.patch("os.replace", failing_manifest_replace):
            result = self._snap(ns, max_variable_bytes=1024, prune_oversized=True)
        self.assertTrue(result["error"].startswith("manifest write failed"))
        with open(self.path, "rb") as fh:
            self.assertNotEqual(fh.read(), old_payload)  # new payload committed
        with open(self.manifest_path, "rb") as fh:
            self.assertEqual(fh.read(), old_manifest)  # old manifest intact
        self._assert_only_pair_files()
        self.assertIn("big", ns)  # not pruned

    def test_sigint_during_final_temp_cleanup_is_parked_and_consumed(self):
        # The handler must stay parked through discard_temps and restore last.
        original = signal.getsignal(signal.SIGINT)
        real_remove = os.remove
        fired = []
        ns = {"keep": 1, "big": b"x" * 100_000}

        def remove_then_sigint(name):
            if not fired:
                fired.append(name)
                signal.raise_signal(signal.SIGINT)
            return real_remove(name)

        with mock.patch("os.remove", remove_then_sigint):
            result = self._snap(ns, max_variable_bytes=1024, prune_oversized=True)
        self.assertNotIn("error", result)  # no KeyboardInterrupt escaped
        self.assertEqual(result["pruned"], ["big"])
        self.assertNotIn("big", ns)  # pruning completed
        self.assertTrue(fired)  # the SIGINT really fired during cleanup
        self.assertIs(signal.getsignal(signal.SIGINT), original)  # handler restored
        self._assert_only_pair_files()

    def test_cleanup_failure_still_restores_sigint_handler(self):
        # A non-OSError from cleanup (e.g. an audit hook) must not skip the restore.
        original = signal.getsignal(signal.SIGINT)
        with mock.patch("os.remove", side_effect=RuntimeError("audit hook")):
            with self.assertRaisesRegex(RuntimeError, "audit hook"):
                self._snap({"keep": 1})
        self.assertIs(signal.getsignal(signal.SIGINT), original)

    def test_aliased_temp_style_names_never_clobber_the_pair(self):
        # Regression: fixed path+'.tmp' temp names aliased the OTHER final path.
        layouts = (
            ("kernel-state.dill", "kernel-state.dill.tmp"),  # manifest == payload + '.tmp'
            ("kernel-state.json.tmp", "kernel-state.json"),  # payload == manifest + '.tmp'
        )
        for payload_name, manifest_name in layouts:
            with self.subTest(payload=payload_name, manifest=manifest_name):
                d = tempfile.mkdtemp(dir=self.dir)
                path = os.path.join(d, payload_name)
                manifest_path = os.path.join(d, manifest_name)
                old_payload, old_manifest = self._old_pair(path, manifest_path)
                with mock.patch("json.dump", side_effect=OSError("disk full")):
                    result = self._snap({"keep": 2}, path, manifest_path)
                self.assertTrue(result["error"].startswith("manifest write failed"))
                self._assert_pair(old_payload, old_manifest, path, manifest_path)
                self.assertEqual(sorted(os.listdir(d)), sorted([payload_name, manifest_name]))
                # A plain success with aliased names must clobber neither file.
                self.assertNotIn("error", self._snap({"keep": 2}, path, manifest_path))
                with open(path, "rb") as fh:
                    self.assertNotEqual(fh.read(), old_payload)  # new payload committed
                with open(manifest_path) as fh:
                    self.assertEqual(json.load(fh)["savedNames"], ["keep"])
                self.assertEqual(sorted(os.listdir(d)), sorted([payload_name, manifest_name]))

    def test_each_variable_serialized_once_and_payload_is_not_a_pickle(self):
        import dill

        from rlm.repl import _SNAPSHOT_MAGIC

        real_dump = dill.dump
        dumped: list[object] = []

        def counting_dump(value, writer):
            dumped.append(value)
            return real_dump(value, writer)

        with mock.patch.object(dill, "dump", counting_dump):
            result = self._snap({"a": 1, "b": 2, "c": 3})
        self.assertEqual(result["saved"], ["a", "b", "c"])
        self.assertEqual(dumped, [1, 2, 3])
        self.assertEqual(result["bytes"], os.path.getsize(self.path))
        with open(self.path, "rb") as fh:
            self.assertEqual(fh.read(len(_SNAPSHOT_MAGIC)), _SNAPSHOT_MAGIC)
            with self.assertRaises(Exception):
                dill.load(fh)


class ErrorEventCapTest(unittest.TestCase):
    """The error event's traceback must fit one protocol frame in aggregate."""

    def setUp(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)

    def test_cap_traceback_lines_keeps_newest_under_the_aggregate_cap(self):
        from rlm.repl import _RESULT_TEXT_CAP, _cap_traceback_lines

        lines = [f"line-{i}: " + "x" * 900 for i in range(2_000)]
        capped = _cap_traceback_lines(lines)
        marker_overhead = len(capped[0])
        self.assertLessEqual(
            sum(len(line) for line in capped),
            _RESULT_TEXT_CAP + marker_overhead + 900,
            "the aggregate (plus the marker and the always-kept newest entry) fits the frame cap",
        )
        self.assertIn("truncated", capped[0])
        self.assertEqual(capped[-1], lines[-1], "the newest entry names the raised exception")
        self.assertEqual(
            _cap_traceback_lines(lines[:10]),
            lines[:10],
            "an under-cap traceback passes through unchanged",
        )


class OwnerWatchdogTest(unittest.TestCase):
    def test_owner_watchdog_exits_busy_runtime(self):
        # The reproduced F4 scenario: stdin stays open (no EOF shutdown), a
        # synchronous cell monopolizes the loop, and only the watchdog thread
        # can notice the owner's death and exit the runtime.
        owner = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(300)"])
        try:
            repl = ReplProcess(env={"PRIME_AGENT_KERNEL_OWNER_PID": str(owner.pid)})
            self.addCleanup(repl.close)
            repl.ready()
            repl.send({"type": "execute", "id": "busy", "code": "while True: pass"})
            time.sleep(1.0)  # let the busy cell start monopolizing the loop
            self.assertIsNone(repl.proc.poll())
            owner.kill()
            owner.wait(timeout=10)
            self.assertEqual(repl.proc.wait(timeout=15), 1)
        finally:
            if owner.poll() is None:
                owner.kill()
                owner.wait(timeout=10)

    def test_resolve_owner_pid_falls_back_to_ppid(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        import rlm.repl as repl_module

        with mock.patch.dict(os.environ, {"PRIME_AGENT_KERNEL_OWNER_PID": "4242"}):
            self.assertEqual(repl_module._resolve_owner_pid(), 4242)
        for raw in (None, "", "garbage", "0", "-7"):
            env = {} if raw is None else {"PRIME_AGENT_KERNEL_OWNER_PID": raw}
            with mock.patch.dict(os.environ, env, clear=False):
                if raw is None:
                    os.environ.pop("PRIME_AGENT_KERNEL_OWNER_PID", None)
                self.assertEqual(repl_module._resolve_owner_pid(), os.getppid())

    def test_owner_watchdog_windows_waits_on_process_handle(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        import rlm.repl as repl_module

        from ctypes import wintypes

        calls: list[tuple] = []

        class FakeFunction:
            def __init__(self, name, result):
                self.name = name
                self.result = result
                self.argtypes = None
                self.restype = None

            def __call__(self, *args):
                calls.append((self.name, *args))
                return self.result

        class FakeKernel32:
            def __init__(self, open_result=1234):
                self.OpenProcess = FakeFunction("OpenProcess", open_result)
                self.WaitForSingleObject = FakeFunction("WaitForSingleObject", 0)
                self.CloseHandle = FakeFunction("CloseHandle", 1)

        k32 = FakeKernel32()
        with mock.patch.object(repl_module.ctypes, "WinDLL", create=True, return_value=k32):
            repl_module._wait_owner_windows(777)
        self.assertEqual(
            calls,
            [
                ("OpenProcess", 0x00100000, False, 777),
                ("WaitForSingleObject", 1234, 0xFFFFFFFF),
                ("CloseHandle", 1234),
            ],
        )
        self.assertEqual(k32.OpenProcess.argtypes, [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD])
        self.assertIs(k32.OpenProcess.restype, wintypes.HANDLE)
        self.assertEqual(k32.WaitForSingleObject.argtypes, [wintypes.HANDLE, wintypes.DWORD])
        self.assertIs(k32.WaitForSingleObject.restype, wintypes.DWORD)
        self.assertEqual(k32.CloseHandle.argtypes, [wintypes.HANDLE])
        self.assertIs(k32.CloseHandle.restype, wintypes.BOOL)

        calls.clear()
        with mock.patch.object(
            repl_module.ctypes, "WinDLL", create=True, return_value=FakeKernel32(open_result=0)
        ):
            repl_module._wait_owner_windows(778)
        self.assertEqual(calls, [("OpenProcess", 0x00100000, False, 778)])


class OwnerExitWaitTest(unittest.TestCase):
    def setUp(self):
        sys.path.insert(0, SRC)
        self.addCleanup(sys.path.remove, SRC)
        import rlm.repl as repl_module

        self.repl_module = repl_module
        self.owner = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(300)"])
        self.addCleanup(self.owner.wait)
        self.addCleanup(self.owner.kill)

    def test_owner_exit_wakes_the_wait_without_polling(self):
        real_alive = self.repl_module._owner_alive_posix

        def owner_exits_once_watched(*args):
            alive = real_alive(*args)  # runs after the exit registration, before the wait
            self.owner.kill()
            return alive

        waiter = threading.Thread(
            target=self.repl_module._wait_owner_posix, args=(self.owner.pid, os.getppid()), daemon=True
        )
        with (
            mock.patch.object(self.repl_module, "_owner_alive_posix", owner_exits_once_watched),
            mock.patch.object(self.repl_module.time, "sleep") as sleep,
        ):
            waiter.start()
            waiter.join(timeout=10)
        self.assertFalse(waiter.is_alive(), "the owner's exit must wake the watchdog")
        sleep.assert_not_called()

    def test_owner_wait_polls_when_exit_registration_fails(self):
        with (
            mock.patch.object(self.repl_module.select, "kqueue", create=True, side_effect=OSError("unavailable")),
            mock.patch.object(self.repl_module.os, "pidfd_open", create=True, side_effect=OSError("unavailable")),
            mock.patch.object(
                self.repl_module.time, "sleep", side_effect=lambda _: (self.owner.kill(), self.owner.wait())
            ) as sleep,
        ):
            self.repl_module._wait_owner_posix(self.owner.pid, os.getppid())
        sleep.assert_called_once()


if __name__ == "__main__":
    unittest.main()