claude-multiacc 2.0.53 → 2.0.55

package/tests/autoresume_tmux_support.py

@@ -0,0 +1,135 @@
+"""Real, isolated tmux fixtures; no provider CLI, credentials, network or schedulers."""
+
+import json
+import os
+from pathlib import Path
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+
+ROOT = Path(__file__).resolve().parents[1]
+SID = "01a0cb0f-a719-7461-bba6-a59bdf2412cc"
+# The shell suite supplies fake tmux on PATH for its own tests; these need the real server.
+ORIGINAL_PATH = os.environ.get("MULTIACC_TEST_ORIGINAL_PATH", os.environ["PATH"])
+TMUX = shutil.which("tmux", path=ORIGINAL_PATH)
+
+
+def seed_pool(home):
+    pool = home / "pool"
+    pool.mkdir()
+    sessions = home / ".codex" / "sessions"
+    sessions.mkdir(parents=True)
+    (pool / "accounts.json").write_text('{"accounts":[],"threshold":90}')
+    (pool / ".limits-kick").touch()
+    for name, percent in (("acct-01", 10), ("acct-02", 30)):
+        account = pool / name
+        account.mkdir()
+        (account / "auth.json").write_text('{"tokens":{"access_token":"test-only"}}')
+        (account / "sessions").symlink_to(sessions, target_is_directory=True)
+        (account / "limits.json").write_text(json.dumps({"fetched_at": int(time.time()),
+            "max_percent": percent, "weekly_percent": percent, "session_percent": 10}, indent=1))
+    return pool
+
+
+def test_environment(home, pool, overrides):
+    fake = home / "fake"
+    fake.mkdir()
+    binary = fake / "codex"
+    binary.write_text("#!" + sys.executable + "\n" +
+                      (ROOT / "tests/fake_codex_tui.py").read_text())
+    binary.chmod(0o755)
+    env = {"HOME": str(home), "PATH": str(fake) + os.pathsep + ORIGINAL_PATH,
+           "TERM": "xterm-256color", "SHELL": "/bin/bash", "LC_ALL": "C", "FAKE_HOME": str(home),
+           "CODEX_ACCOUNTS_ROOT": str(pool), "CODEX_MULTIACC_PYTHON": sys.executable,
+           "CODEX_MULTIACC_AUTORESUME": "1", "CODEX_MULTIACC_AUTORESUME_DEBUG": "1",
+           "CODEX_MULTIACC_MCP": "0", "CODEX_MULTIACC_AUTO_RESET": "0", "CODEX_MULTIACC_NO_SYNC": "1",
+           "CODEX_MULTIACC_CLIENT_LIMITS": "0", "CODEX_MULTIACC_HEADROOM_BAND": "0",
+           "CODEX_MULTIACC_USAGE_URL": "file:///nonexistent", "CODEX_MULTIACC_TOKEN_URL": "file:///nonexistent",
+           "CODEX_MULTIACC_AR_POLL": "0.05", "CODEX_MULTIACC_AR_GRACE": "0.4",
+           "CODEX_MULTIACC_AR_HOLD_REPROBE": "0.3", "CODEX_MULTIACC_AR_TERM_GRACE": "0.3",
+           "CODEX_MULTIACC_AR_PANE_WAIT": "4", "CODEX_MULTIACC_AR_RELAUNCH_WAIT": "5",
+           "CODEX_MULTIACC_AR_PROMPT_WAIT": "2",
+           "CODEX_MULTIACC_AR_TRANSIENT_LADDER": "0.4", "FAKE_SID": SID}
+    env.update(overrides)
+    return env
+
+
+class TmuxScenario:
+    def __init__(self, **overrides):
+        self.temp = tempfile.TemporaryDirectory(prefix="ar-tmux-", dir="/tmp")
+        self.home = Path(self.temp.name).resolve()
+        self.pool = seed_pool(self.home)
+        self.work = self.home / "work"
+        self.work.mkdir()
+        self.sock = self.home / "tmux.sock"
+        self.env = test_environment(self.home, self.pool, overrides)
+        self.pane = "%0"
+        self.log = self.pool / "selection.log"
+        self.rollout = self.home / ".codex/sessions/2026/10/10" / ("rollout-test-" + SID + ".jsonl")
+
+    def tmux(self, *args, check=True):
+        result = subprocess.run([TMUX, "-S", str(self.sock), "-f", "/dev/null", *args],
+                                env=self.env, capture_output=True, text=True, timeout=10)
+        if check and result.returncode:
+            raise AssertionError(result.stderr)
+        return result.stdout.strip()
+
+    def start(self, args=None, supervised=True):
+        self.pane = self.tmux("new-session", "-d", "-P", "-F", "#{pane_id}", "-s", "case",
+                              "-c", str(self.work), "/bin/bash", "--noprofile", "--norc", "-i")
+        command = shlex.join([str(ROOT / "bin/codex"), *(args if args is not None else ["--yolo"])])
+        self.tmux("send-keys", "-t", self.pane, "-l", command)
+        self.tmux("send-keys", "-t", self.pane, "Enter")
+        self.wait(lambda: len(self.records("ready")) == 1, "first fake TUI ready")
+        if supervised:
+            self.wait(lambda: "autoresume watch" in self.log.read_text(), "watcher started")
+
+    def records(self, kind=None):
+        path = self.home / "provider.jsonl"
+        try:
+            rows = [json.loads(line) for line in path.read_text().splitlines()]
+        except (OSError, ValueError):
+            return []
+        return [row for row in rows if kind is None or row["kind"] == kind]
+
+    def append(self, payload, age=0):
+        timestamp = time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(time.time() - age)) + ".999Z"
+        with self.rollout.open("a") as target:
+            target.write(json.dumps({"timestamp": timestamp, "type": "event_msg", "payload": payload}) + "\n")
+
+    def wait(self, predicate, label, timeout=12):
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if predicate():
+                return
+            time.sleep(0.05)
+        logs = self.log.read_text() if self.log.exists() else "no selection log"
+        logs += "\n" + self.tmux("capture-pane", "-p", "-t", self.pane, check=False)
+        for path in (self.pool / "tmp/autoresume").glob("*.log"):
+            logs += "\n" + path.read_text()
+        raise AssertionError(label + " timed out:\n" + logs)
+
+    def close(self):
+        if not self.home.exists():
+            return
+        (self.pool / "autoresume.off").touch()
+        deadline = time.monotonic() + 3
+        while list((self.pool / "tmp/autoresume").glob("*.state")) and time.monotonic() < deadline:
+            time.sleep(0.05)
+        if self.sock.exists():
+            self.tmux("kill-server", check=False)
+        processes = subprocess.run(["ps", "-A", "-o", "pid=,args="], capture_output=True,
+                                   text=True, env=self.env, timeout=5).stdout
+        owned = "watch --state " + str(self.pool / "tmp/autoresume") + "/"
+        for row in processes.splitlines():
+            parts = row.strip().split(None, 1)
+            if len(parts) == 2 and owned in parts[1]:
+                try:
+                    os.kill(int(parts[0]), signal.SIGTERM)
+                except ProcessLookupError:
+                    pass
+        self.temp.cleanup()

package/tests/fake_codex_tui.py

@@ -0,0 +1,81 @@
+"""A fake foreground Codex that holds its rollout open and records every received key."""
+
+import json
+import os
+from pathlib import Path
+import select
+import signal
+import sys
+import termios
+import time
+import tty
+
+
+def record(kind, **fields):
+    with (Path(os.environ["FAKE_HOME"]) / "provider.jsonl").open("a") as target:
+        target.write(json.dumps(dict(kind=kind, pid=os.getpid(), **fields)) + "\n")
+
+
+def stop(signum, _frame):
+    record("signal", signal=signum)
+    if os.environ.get("FAKE_IGNORE_TERM") == "1" and signum == signal.SIGTERM:
+        return
+    raise SystemExit(0)
+
+
+def initialize_rollout():
+    sid = os.environ["FAKE_SID"]
+    directory = Path(os.environ["CODEX_HOME"]) / "sessions/2026/10/10"
+    directory.mkdir(parents=True, exist_ok=True)
+    rollout = (directory / ("rollout-test-" + sid + ".jsonl")).open("a+")
+    if rollout.tell() == 0:
+        stamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        rollout.write(json.dumps({"timestamp": stamp, "type": "session_meta", "payload": {
+            "id": sid, "session_id": sid, "timestamp": stamp,
+            "cwd": os.getcwd(), "source": "cli"}}) + "\n")
+    local = "--no-daemon" in sys.argv or "FAKE_LEGACY" in os.environ
+    if "resume" in sys.argv and sid in sys.argv and local and "FAKE_DROP_PROMPT" not in os.environ:
+        prompt = sys.argv[-1]
+        if " " in prompt:
+            stamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+            rollout.write(json.dumps({"timestamp": stamp, "type": "response_item", "payload": {
+                "type": "message", "role": "user",
+                "content": [{"type": "input_text", "text": prompt}]}}) + "\n")
+            rollout.write(json.dumps({"timestamp": stamp, "type": "event_msg",
+                                     "payload": {"type": "task_started"}}) + "\n")
+            record("prompt", text=prompt)
+    rollout.flush()
+    if not local:
+        rollout.close()  # Modern daemon owns the writer; the foreground client has no rollout fd.
+    return rollout
+
+
+def main():
+    if sys.argv[1:] == ["--help"]:
+        print("Usage: codex [OPTIONS]\n" + ("  --no-daemon  Run locally" if "FAKE_LEGACY" not in os.environ else ""))
+        return
+    if sys.argv[1:] == ["--version"]:
+        print("codex-cli test")
+        return
+    record("launch", argv=sys.argv[1:], cwd=os.getcwd(), account=Path(os.environ["CODEX_HOME"]).name)
+    settings = termios.tcgetattr(0)
+    signal.signal(signal.SIGTERM, stop)
+    signal.signal(signal.SIGHUP, stop)
+    rollout = initialize_rollout()
+    try:
+        tty.setraw(0)
+        record("ready")
+        print("FAKE CODEX READY", flush=True)
+        while True:
+            if select.select([0], [], [], 0.1)[0]:
+                data = os.read(0, 4096)
+                if not data:
+                    return
+                record("keys", data=data.hex())
+    finally:
+        rollout.close()
+        termios.tcsetattr(0, termios.TCSANOW, settings)
+
+
+if __name__ == "__main__":
+    main()

package/tests/run-tests.sh

@@ -3,6 +3,7 @@
 # No network, no real accounts, no quota: fake `claude`/`codex` binaries + file://
 # usage/token fixtures.
 set -u
+export MULTIACC_TEST_ORIGINAL_PATH="$PATH"
 
 REPO_DIR="$(cd "$(dirname "$0")/.." && pwd -P)"
 WORK="$(mktemp -d "${TMPDIR:-/tmp}/multiacc-test.XXXXXX")" || exit 1
@@ -5156,6 +5157,12 @@ exec 9>>"$ro"
 trap 'exit 0' TERM
 trap 'exit 0' HUP
 if [ "$resumed" = 1 ]; then
+  python3 - "$ro" "${!#}" <<'PY'
+import json, sys
+with open(sys.argv[1], 'a') as stream:
+    stream.write(json.dumps({'type': 'event_msg', 'payload': {
+        'type': 'user_message', 'message': sys.argv[2]}}) + '\n')
+PY
   [ -n "${FAKE_TUI_QUIET:-}" ] \
     || printf '{"timestamp":"%s","type":"event_msg","payload":{"type":"task_started","turn_id":"2"}}\n' "$(ts)" >&9
 else
@@ -5179,6 +5186,7 @@ EOF
 cat > "$FAKEBIN/codex" <<EOF
 #!/usr/bin/env bash
 # fake real codex for tests (not a shim)
+if [ "\${1:-}" = --help ]; then echo 'Usage: legacy codex [OPTIONS]'; exit 0; fi
 if [ "\${1:-}" = "mcp" ] && [ -n "\${CODEX_HOME:-}" ]; then
   python3 "$FAKE_CODEX_MCP" "\$CODEX_HOME/config.toml" "\$@"
   rc=\$?
@@ -9237,7 +9245,8 @@ if ar_wait 30 ar_lines 2 "$ARB/tui.log"; then
     && t_ok "AR codex quota: the old account gets the 10-minute error-cooldown, never client:7d" \
     || t_fail "AR codex quota: cooldown marker" "$m1 / $m2"
   ar_logged "$ARX" "autoresume relaunch chain=[A-Za-z0-9]+ from=$from class=quota depth=1\$" \
-    && ar_logged "$ARX" "autoresume switch provider=codex chain=[A-Za-z0-9]+ from=$from class=quota sid=$AR_CXSID depth=1 probe=$to" \
+    && ar_wait 5 ar_logged "$ARX" \
+      "autoresume switch provider=codex chain=[A-Za-z0-9]+ from=$from class=quota sid=$AR_CXSID depth=1 probe=$to" \
     && t_ok "AR codex quota: switch + relaunch logged" \
     || t_fail "AR codex quota: log lines" "$(grep autoresume "$ARX/selection.log")"
   ar_typed_ok CODEX "$AR_CXSID" "CODEX_ACCOUNTS_ROOT=$(cd "$ARX" && pwd)" "$REPO_DIR/bin/codex" \

package/tests/test_autoresume.py

@@ -1033,6 +1033,13 @@ class FakeRunner:
         except OSError:
             return
         self.consumed[tok] = (text, data)
+        fields = ar.parse_kv(text, ar.RELAUNCH_KEYS)
+        if fields.get("provider") == "codex":
+            for path in Path(self.ar_dir).parent.parent.glob("acct-*/sessions/*/*/*/rollout-*.jsonl"):
+                if fields["sid"] in path.name:
+                    append(path, [cx_event(self.t, {"type": "user_message",
+                                                  "message": ar.decode_argv(data)[-1]})])
+                    break
         ar.remove_quietly(base + ".relaunch", base + ".argv")
 
     def run(self, argv, timeout, env=None, cwd=None):

package/tests/test_autoresume_codex_records.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Replay current Codex rollout shapes through the complete watcher, without a real pool."""
+
+import signal
+import unittest
+
+import test_autoresume as fixtures
+
+
+class CurrentCodexRecordsTests(unittest.TestCase):
+    def setUp(self):
+        self.pool = fixtures.CodexWatcherTests(methodName="runTest")
+        self.pool.setUp()
+        self.addCleanup(self.pool.tearDown)
+
+    def records(self):
+        pool = self.pool
+        reset = int(pool.t0) + 86400
+        meta = fixtures.cx_meta(pool.launched - 3600, cwd=str(pool.work))
+        meta["payload"]["cli_version"] = "0.162.1"
+        error = fixtures.cx_error(pool.t0 - 1, "usage_limit_exceeded")
+        error["payload"].update(root_turn_id=error["payload"]["turn_id"],
+                                time_to_first_token_ms=31)
+        return [meta, fixtures.cx_tokens(pool.t0 - 2, primary={
+            "used_percent": 100.0, "window_minutes": 10080, "resets_at": reset}),
+            fixtures.cx_tokens(pool.t0 - 1, limit_id="premium"), error], reset
+
+    def test_current_epoch_error_and_weekly_snapshot_resume_same_session(self):
+        pool = self.pool
+        records, reset = self.records()
+        rc, watcher, runner, _ = pool.run_codex(["resume", fixtures.CX_SID], records)
+        self.assertEqual(rc, 0)
+        fields, argv = pool.relaunch_of(runner)
+        self.assertEqual(fields["sid"], fixtures.CX_SID)
+        self.assertEqual(fields["reset"], str(reset))
+        self.assertEqual(argv, ["resume", fixtures.CX_SID, fixtures.ar.resume_prompt("quota")])
+        self.assertEqual(watcher.tracker.pending["rtype_window"], "7d")
+        self.assertEqual(runner.signals, [(pool.PID, signal.SIGTERM)])
+        self.assertEqual(pool.events(), ["watch", "detect", "switch"])
+
+    def test_paginated_user_turn_cancels_before_restart(self):
+        pool = self.pool
+        records, _ = self.records()
+
+        def setup(watcher, runner, path):
+            started = fixtures.cx_event(pool.t0 + 1, {"type": "task_started"})
+            user = {"timestamp": fixtures.iso(pool.t0 + 1), "type": "response_item",
+                    "payload": {"type": "message", "role": "user", "content": [
+                        {"type": "input_text", "text": "Resume the current task"}]}}
+            runner.at(pool.t0 + 1, lambda: fixtures.append(path, [started, user]))
+            runner.at(pool.t0 + 10, lambda: runner.exit(pool.PID))
+
+        rc, watcher, runner, _ = pool.run_codex(["resume", fixtures.CX_SID], records, setup=setup)
+        self.assertEqual(rc, 0)
+        self.assertIsNone(watcher.tracker.pending)
+        self.assertEqual((runner.probes, runner.signals, runner.sends), ([], [], []))
+
+    def test_old_epoch_error_in_resumed_paginated_rollout_is_ignored(self):
+        pool = self.pool
+        records, _ = self.records()
+        records[-1]["payload"]["completed_at"] = pool.launched - 3600
+
+        def setup(watcher, runner, path):
+            runner.at(pool.t0 + 10, lambda: runner.exit(pool.PID))
+
+        rc, watcher, runner, _ = pool.run_codex(["resume", fixtures.CX_SID], records, setup=setup)
+        self.assertEqual(rc, 0)
+        self.assertIsNone(watcher.tracker.pending)
+        self.assertEqual((runner.probes, runner.signals, runner.sends), ([], [], []))
+        self.assertEqual(pool.events(), ["watch"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_cursor.py

@@ -0,0 +1,87 @@
+"""Relaunched watchers ignore exactly the previous client's persisted rollout bytes."""
+
+from pathlib import Path
+import signal
+import unittest
+
+import test_autoresume as fixtures
+from autoresume_receipt import apply_cursor, cursor_value
+
+
+class CursorTests(unittest.TestCase):
+    def setUp(self):
+        self.pool = fixtures.CodexWatcherTests(methodName="runTest")
+        self.pool.setUp()
+        self.addCleanup(self.pool.tearDown)
+
+    def resumed_watcher(self):
+        pool = self.pool
+        state = pool.write_state(["resume", fixtures.CX_SID], provider="codex", launched=int(pool.t0))
+        path = pool.rollout([fixtures.cx_meta(pool.t0 - 3600, cwd=str(pool.work)),
+                             fixtures.cx_error(pool.t0, "usage_limit_exceeded")])
+        info = path.stat()
+        cursor = "%d:%d" % (info.st_ino, info.st_size)
+        state_path = Path(state)
+        state_path.write_text(state_path.read_text() + "rollout_cursor=" + cursor + "\n")
+        watcher, runner = pool.watcher(state, {"CODEX_MULTIACC_AR_GRACE": "0.1",
+                                              "CODEX_MULTIACC_AR_POLL": "0.05"})
+        runner.pane_cmd = "node"
+        return watcher, runner, path, cursor
+
+    def test_same_second_previous_quota_does_not_restart_new_client(self):
+        watcher, runner, _, cursor = self.resumed_watcher()
+        runner.at(self.pool.t0 + 1, lambda: runner.exit(self.pool.PID))
+        self.assertEqual(watcher.run(), 0)
+        self.assertEqual(watcher.st["rollout_cursor"], cursor)
+        self.assertIsNone(watcher.tracker.pending)
+        self.assertEqual((runner.probes, runner.signals, runner.sends), ([], [], []))
+        self.assertEqual(self.pool.events(), ["watch"])
+
+    def test_new_quota_after_cursor_restarts_even_with_same_timestamp(self):
+        watcher, runner, path, _ = self.resumed_watcher()
+        runner.at(self.pool.t0 + 0.2, lambda: fixtures.append(path, [
+            fixtures.cx_error(self.pool.t0, "usage_limit_exceeded")]))
+        self.assertEqual(watcher.run(), 0)
+        self.assertEqual(self.pool.events(), ["watch", "detect", "switch"])
+        self.assertEqual(runner.signals, [(self.pool.PID, signal.SIGTERM)])
+        fields, argv = self.pool.relaunch_of(runner)
+        inode, offset = cursor_value(fields["rollout_cursor"])
+        self.assertEqual(inode, path.stat().st_ino)
+        self.assertLess(offset, path.stat().st_size)
+        self.assertEqual(argv[-2], fixtures.CX_SID)
+
+    def test_replaced_rollout_refuses_without_stopping_client(self):
+        watcher, runner, path, _ = self.resumed_watcher()
+        replacement = path.with_suffix(".replacement")
+        replacement.write_bytes(path.read_bytes())
+        replacement.replace(path)
+        self.assertEqual(watcher.run(), 0)
+        self.assertEqual(self.pool.events(), ["watch", "giveup"])
+        self.assertIn("reason=rollout-replaced", self.pool.log_lines()[-1])
+        self.assertEqual((runner.probes, runner.signals, runner.sends), ([], [], []))
+
+    def test_truncated_rollout_refuses_without_stopping_client(self):
+        watcher, runner, path, _ = self.resumed_watcher()
+        path.write_bytes(path.read_bytes().splitlines(keepends=True)[0])
+        self.assertEqual(watcher.run(), 0)
+        self.assertIn("reason=rollout-replaced", self.pool.log_lines()[-1])
+        self.assertEqual((runner.probes, runner.signals, runner.sends), ([], [], []))
+
+    def test_absent_cursor_preserves_legacy_behavior(self):
+        _, _, path, _ = self.resumed_watcher()
+        for cursor in (None, ""):
+            tail = fixtures.ar.JsonlTail(path)
+            self.assertTrue(apply_cursor(tail, cursor))
+            self.assertEqual(tail.off, 0)
+            self.assertEqual(len(tail.read_lines()), 2)
+
+    def test_malformed_present_cursor_refuses_instead_of_replaying_history(self):
+        _, _, path, _ = self.resumed_watcher()
+        for cursor in ("1::2", "1:2:3", "1", "-1:2", "1:-2", "1:a", "9" * 21 + ":2"):
+            with self.subTest(cursor=cursor):
+                self.assertIsNone(cursor_value(cursor))
+                self.assertFalse(apply_cursor(fixtures.ar.JsonlTail(path), cursor))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_mode.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Capability detection uses disposable local CLIs, never account credentials."""
+
+import importlib.util
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+
+LIB = Path(__file__).resolve().parents[1] / "lib" / "codex_autoresume_mode.py"
+SPEC = importlib.util.spec_from_file_location("codex_autoresume_mode", LIB)
+mode = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(mode)
+
+
+class NativeModeTests(unittest.TestCase):
+    def setUp(self):
+        self.scratch = tempfile.TemporaryDirectory(prefix="codex-ar-mode-")
+        self.addCleanup(self.scratch.cleanup)
+        self.root = Path(self.scratch.name)
+        self.executable = self.root / "codex"
+
+    def executable_with(self, body):
+        self.executable.write_text("#!" + sys.executable + "\n" + body)
+        self.executable.chmod(0o700)
+        return str(self.executable)
+
+    def test_advertised_option_is_detected_and_cli_only_outputs_flag(self):
+        executable = self.executable_with(
+            "import sys\nassert sys.argv[1:] == ['--help']\n"
+            "print('Options:\\n      --no-daemon\\n          Run without shared server')\n"
+        )
+        self.assertTrue(mode.supports_no_daemon(executable))
+        result = subprocess.run([sys.executable, "-I", str(LIB), executable],
+                                capture_output=True, text=True, timeout=5)
+        self.assertEqual((result.returncode, result.stdout, result.stderr), (0, "--no-daemon\n", ""))
+
+    def test_old_cli_and_mentions_without_option_are_not_supported(self):
+        for help_text in ("Options:\n  --help", "Use --no-daemon if available", "  --no-daemon-other"):
+            with self.subTest(help_text=help_text):
+                executable = self.executable_with("print(%r)\n" % help_text)
+                self.assertFalse(mode.supports_no_daemon(executable))
+
+    def test_failed_help_and_missing_binary_fail_open(self):
+        executable = self.executable_with("print('  --no-daemon')\nraise SystemExit(2)\n")
+        self.assertFalse(mode.supports_no_daemon(executable))
+        self.assertFalse(mode.supports_no_daemon(str(self.root / "missing")))
+
+    def test_updates_are_checked_without_stale_capability_cache(self):
+        executable = self.executable_with("print('  --help')\n")
+        self.assertFalse(mode.supports_no_daemon(executable))
+        self.executable_with("print('  --no-daemon')\n")
+        self.assertTrue(mode.supports_no_daemon(executable))
+        self.executable_with("print('  --help')\n")
+        self.assertFalse(mode.supports_no_daemon(executable))
+
+    def test_large_output_and_stderr_do_not_advertise_option(self):
+        executable = self.executable_with(
+            "import sys\nsys.stdout.write('x' * %d + '\\n  --no-daemon\\n')\n"
+            "sys.stderr.write('  --no-daemon\\n')\n" % mode.MAX_HELP_BYTES
+        )
+        self.assertFalse(mode.supports_no_daemon(executable))
+
+    def test_timeout_stops_probe_and_its_child_without_touching_other_processes(self):
+        marker = self.root / "child-finished"
+        executable = self.executable_with(
+            "import os, time\n"
+            "if os.fork() == 0:\n"
+            "    time.sleep(0.5)\n"
+            "    open(%r, 'w').write('unexpected')\n"
+            "    os._exit(0)\n"
+            "time.sleep(20)\n" % str(marker)
+        )
+        other = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(20)"])
+        self.addCleanup(other.wait)
+        self.addCleanup(other.terminate)
+        started = time.monotonic()
+        self.assertFalse(mode.supports_no_daemon(executable, timeout=0.1))
+        self.assertLess(time.monotonic() - started, 2)
+        time.sleep(0.6)
+        self.assertFalse(marker.exists())
+        self.assertIsNone(other.poll())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_receipt.py

@@ -0,0 +1,117 @@
+"""Receipt checks require newly persisted user input in the bound conversation."""
+
+import json
+from pathlib import Path
+import signal
+import tempfile
+from types import SimpleNamespace
+import unittest
+from unittest import mock
+
+import test_autoresume as fixtures
+from autoresume_receipt import codex_prompt_record, confirm_prompt, receipt_tail
+
+
+class ReceiptTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(temporary.cleanup)
+        self.path = Path(temporary.name) / "rollout.jsonl"
+        self.path.write_bytes(b"{}\n")
+        self.prompt = fixtures.ar.resume_prompt("quota")
+        self.record = json.dumps({"type": "event_msg", "payload": {
+            "type": "user_message", "message": self.prompt}}).encode() + b"\n"
+        self.runner = fixtures.FakeRunner(100, 4242, 777, "/fake/codex")
+        self.watcher = SimpleNamespace(r=self.runner, switched_off=lambda: False,
+                                       cfg=SimpleNamespace(prompt_wait=0.5, poll=0.05))
+
+    def test_new_exact_user_records_confirm(self):
+        response = json.dumps({"type": "response_item", "payload": {
+            "type": "message", "role": "user", "content": [
+                {"type": "input_text", "text": self.prompt}]}}).encode() + b"\n"
+        for raw in (self.record, response):
+            with self.subTest(raw=raw):
+                tail = receipt_tail(self.path, fixtures.ar.JsonlTail)
+                self.path.write_bytes(self.path.read_bytes() + raw)
+                self.assertTrue(confirm_prompt(self.watcher, tail, self.prompt))
+
+    def test_wrong_quoted_and_malformed_records_do_not_confirm(self):
+        records = [None, [], {}, {"type": "event_msg", "payload": []}]
+        records += [{"type": "event_msg", "payload": {"type": kind, "message": self.prompt}}
+                    for kind in ("agent_message", "task_complete", "error")]
+        records += [{"type": "response_item", "payload": {
+            "type": "message", "role": role, "content": [
+                {"type": "input_text", "text": self.prompt}]}}
+            for role in ("assistant", "tool", "system")]
+        records += [{"type": "event_msg", "payload": {"type": "user_message", "message": text}}
+                    for text in (self.prompt + " extra", "quoted: " + self.prompt, self.prompt[:40])]
+        for record in records:
+            self.assertFalse(codex_prompt_record(json.dumps(record), self.prompt), record)
+        for raw in (b"{", b"\xff", None):
+            self.assertFalse(codex_prompt_record(raw, self.prompt))
+
+    def test_historical_identical_prompt_is_not_a_receipt(self):
+        self.path.write_bytes(self.record)
+        tail = receipt_tail(self.path, fixtures.ar.JsonlTail)
+        self.assertFalse(confirm_prompt(self.watcher, tail, self.prompt))
+        self.assertGreaterEqual(self.runner.now(), 100.5)
+
+    def test_partial_json_line_waits_for_completion(self):
+        tail = receipt_tail(self.path, fixtures.ar.JsonlTail)
+        prefix = self.path.read_bytes()
+        self.path.write_bytes(prefix + self.record[:-1])
+        self.runner.at(100.2, lambda: self.path.write_bytes(prefix + self.record))
+        self.assertTrue(confirm_prompt(self.watcher, tail, self.prompt))
+        self.assertGreaterEqual(self.runner.now(), 100.2)
+
+    def test_delayed_new_prompt_is_confirmed(self):
+        tail = receipt_tail(self.path, fixtures.ar.JsonlTail)
+        self.runner.at(100.3, lambda: self.path.write_bytes(self.path.read_bytes() + self.record))
+        self.assertTrue(confirm_prompt(self.watcher, tail, self.prompt))
+        self.assertGreaterEqual(self.runner.now(), 100.3)
+
+    def test_replaced_or_truncated_rollout_is_rejected(self):
+        for replace in (False, True):
+            with self.subTest(replace=replace):
+                self.path.write_bytes(self.record * 3)
+                tail = receipt_tail(self.path, fixtures.ar.JsonlTail)
+                replacement = self.path.with_suffix(".replacement") if replace else self.path
+                replacement.write_bytes(self.record)
+                if replace:
+                    replacement.replace(self.path)
+                self.assertFalse(confirm_prompt(self.watcher, tail, self.prompt))
+
+    def test_missing_file_and_kill_switch_stop_waiting(self):
+        tail = receipt_tail(self.path, fixtures.ar.JsonlTail)
+        self.watcher.switched_off = lambda: True
+        self.assertFalse(confirm_prompt(self.watcher, tail, self.prompt))
+        self.path.unlink()
+        self.assertFalse(confirm_prompt(self.watcher, tail, self.prompt))
+        self.assertEqual(self.runner.now(), 100)
+
+    def test_receipt_requires_an_existing_rollout(self):
+        self.assertIsNone(receipt_tail(None, fixtures.ar.JsonlTail))
+        self.assertIsNone(receipt_tail(self.path.with_name("missing"), fixtures.ar.JsonlTail))
+
+    def test_consumed_token_without_prompt_never_reports_switch(self):
+        pool = fixtures.CodexWatcherTests(methodName="runTest")
+        pool.setUp()
+        self.addCleanup(pool.tearDown)
+        records = [fixtures.cx_meta(pool.launched - 3600, cwd=str(pool.work)),
+                   fixtures.cx_event(pool.launched - 10, {"type": "user_message", "message": self.prompt}),
+                   fixtures.cx_error(pool.t0, "usage_limit_exceeded")]
+        with mock.patch.object(fixtures, "append"):
+            rc, _, runner, _ = pool.run_codex(["resume", fixtures.CX_SID], records,
+                                             env={"CODEX_MULTIACC_AR_PROMPT_WAIT": "0.5"})
+        self.assertEqual(rc, 0)
+        self.assertTrue(runner.consumed)
+        self.assertEqual(pool.events(), ["watch", "detect", "giveup"])
+        self.assertIn("reason=prompt", pool.log_lines()[-1])
+        self.assertIn('resume="codex resume ' + fixtures.CX_SID, pool.log_lines()[-1])
+        self.assertEqual(runner.signals, [(pool.PID, signal.SIGTERM)])
+        self.assertEqual((len(runner.sends), len(runner.notices)), (4, 1))
+        self.assertEqual(pool.relaunch_files(), [])
+
+
+if __name__ == "__main__":
+    unittest.main()