claude-multiacc 2.0.57 → 2.0.59

package/tests/test_autoresume_sidechain.py

@@ -0,0 +1,1518 @@
+#!/usr/bin/env python3
+"""Account-level rejections that only a claude session's subagent and workflow transcripts
+record. 2026-10-19: two sessions sat idle behind paused workflows whose agents alone had
+met the five-hour limit, and the watcher, tailing the main transcript only, never moved
+them. Disposable pools, the fake runner and its fake clock only: no real signal or tmux."""
+
+import json
+import os
+import signal
+import unittest
+from unittest import mock
+
+import test_autoresume as fixtures
+from test_autoresume import (SID, SID2, ar, cc_api_error, cc_concurrents, cc_quota, cc_reply,
+                             cc_slash, cc_user, iso)
+
+AGENT = "a33659a7131e55067"
+AGENT2 = "ab12cd34ef56a7890"
+AGENT3 = "a0f1e2d3c4b5a6978"
+
+
+def side(rec, agent=AGENT):
+    """A record as a subagent transcript holds it (claude 2.1.303): the session's
+    sidechain, named by its agent."""
+    return dict(rec, isSidechain=True, agentId=agent)
+
+
+def side_quota(ts, resets, agent=AGENT, rtype="five_hour"):
+    rec = cc_quota(ts, rtype, resets=resets, apiError="usage_limit_reached")
+    rec["message"]["content"][0]["text"] = ("You've hit your session limit · resets 12:40am "
+                                            "(Europe/Istanbul)")
+    return side(rec, agent)
+
+
+def side_reply(ts, agent=AGENT, text="Checked the build.", ref=None):
+    rec = side(cc_reply(ts, text), agent)
+    if ref:
+        rec["requestRef"] = ref
+    return rec
+
+
+def final_answer(ts, agent, ref):
+    """An agent's last reply (end_turn): nothing of that agent follows it."""
+    rec = side_reply(ts, agent, "All done: the section is written.", ref)
+    rec["message"]["stop_reason"] = "end_turn"
+    return rec
+
+
+def api_request(ts, rid, agent=None):
+    """What claude 2.1.303 writes right before it sends a request, in an agent's transcript
+    and the main one alike; every reply to that request names it by requestRef."""
+    rec = {"type": "api-request", "sessionId": SID, "id": rid, "timestamp": iso(ts),
+           "version": "2.1.303", "querySource": "repl_main_thread", "shapeHash": "9f2c41",
+           "params": {"model": "claude-opus-5-5", "max_tokens": 64000}, "keep": 0, "tail": 1,
+           "cacheControl": "5m", "requestDigest": "4b1d0c"}
+    if agent:
+        rec.update(agentId=agent, querySource="agent:builtin:workflow-subagent")
+    return rec
+
+
+def main_reply(ts, ref, text="Done."):
+    return dict(cc_reply(ts, text), requestRef=ref)
+
+
+def queue_op(ts):
+    """All an idle main transcript waiting on its workflows still gets."""
+    return {"type": "queue-operation", "operation": "enqueue", "timestamp": iso(ts),
+            "sessionId": SID, "content": "<task-notification>paused</task-notification>"}
+
+
+def request_blob():
+    """A request body the client keeps among the records (claude 2.1.303): no timestamp of
+    its own, and it quotes the conversation's "assistant" turns."""
+    return {"type": "api-request-blob", "hash": "5d41402abc4b2a76b9719d911017c592",
+            "sessionId": SID, "message": {"role": "assistant", "content": [
+                {"type": "text", "text": "Started it; waiting for the workflow."}]}}
+
+
+def tool_result(ts):
+    return cc_user(ts, [{"type": "tool_result", "tool_use_id": "toolu_1", "content": "ok"}],
+                   toolUseResult={"stdout": "ok"})
+
+
+def synthetic(ts, text="No response requested."):
+    """The client's own words in the main thread, no API error and no reply of the API's."""
+    rec = cc_reply(ts, text)
+    rec["message"]["model"] = "<synthetic>"
+    return rec
+
+
+def compact(records):
+    """JSONL as the client writes it: compact JSON, a record a line."""
+    return "".join(json.dumps(rec, separators=(",", ":")) + "\n" for rec in records)
+
+
+def write(path, records):
+    with open(path, "a") as fh:
+        fh.write(compact(records))
+
+
+def main_lines(records):
+    """Main transcript lines as the client writes them (compact JSON)."""
+    return [line.encode() for line in compact(records).splitlines()]
+
+
+class SidechainCase(fixtures.PoolCase):
+    def agent_file(self, records, agent=AGENT, workflow="wf_7f3a9c", sid=SID, mtime=None):
+        """<proj>/<sid>/subagents/workflows/<wf>/agent-<id>.jsonl (workflow=None: an Agent
+        tool subagent, <sid>/subagents/agent-<id>.jsonl)."""
+        folder = self.proj / sid / "subagents"
+        if workflow:
+            folder = folder / "workflows" / workflow
+        folder.mkdir(parents=True, exist_ok=True)
+        path = folder / ("agent-%s.jsonl" % agent)
+        write(path, records)
+        if mtime is not None:
+            os.utime(str(path), (mtime, mtime))
+        return path
+
+    def transcript(self, records, sid=SID):
+        path = self.proj / (sid + ".jsonl")
+        write(path, records)
+        return path
+
+    def start(self, argv=None, main=None, env=None):
+        """A session whose main thread started workflows and has idled on them since."""
+        state = self.write_state(["--dangerously-skip-permissions"] if argv is None else argv)
+        self.registry()
+        self.transcript([cc_user(self.launched + 1, "run the release workflow"),
+                         cc_reply(self.launched + 2, "Started it; waiting for the workflow."),
+                         queue_op(self.t0 - 1)] if main is None else main)
+        return self.watcher(state, env)
+
+    def stop_at(self, runner, when):
+        """The operator ends the session (/exit: its registry goes)."""
+        reg = self.root / "acct-01" / "sessions" / ("%d.json" % self.PID)
+        runner.at(when, lambda: (reg.unlink() if reg.exists() else None,
+                                 runner.exit(self.PID)))
+
+    def tail_of(self, watcher, name):
+        found = [tail for path, tail in watcher.side.items() if os.path.basename(path) == name]
+        self.assertEqual(len(found), 1, sorted(watcher.side))
+        return found[0]
+
+    def assert_untouched(self, runner):
+        self.assertEqual((runner.probes, runner.signals, runner.sends, self.relaunch_files()),
+                         ([], [], [], []))
+
+
+# =====================================================================================
+# classification and the tracker
+# =====================================================================================
+
+class SidechainClassifierTests(unittest.TestCase):
+    T = 1792440000
+
+    def test_only_the_accounts_own_verdicts_count(self):
+        verdicts = {
+            "quota": side_quota(self.T, self.T + 6000),
+            "auth": side(cc_api_error(self.T, "authentication_failed", "Not logged in")),
+            "blocked": side(cc_api_error(self.T, "oauth_org_not_allowed")),
+        }
+        for cls, rec in verdicts.items():
+            kind, verdict = ar.classify_claude_sidechain(rec)
+            self.assertEqual((kind, verdict["class"]), ("error", cls))
+        _, quota = ar.classify_claude_sidechain(verdicts["quota"])
+        self.assertEqual((quota["reset"], quota["rtype"], quota["marked"]),
+                         (self.T + 6000, "five_hour", ar.utc_iso(self.T)))
+        _, org = ar.classify_claude_sidechain(verdicts["blocked"])
+        self.assertEqual(org["rtype"], "oauth_org_not_allowed")
+        # the subagent's own business: its model's bucket, a transient error, the rest
+        for rec in (side_quota(self.T, self.T + 60, rtype="seven_day_opus"),
+                    side(cc_api_error(self.T, "rate_limit", "You've reached your Fable limit.")),
+                    side(cc_api_error(self.T, "rate_limit", "nope",
+                                      apiError="model_requires_usage_credits")),
+                    side(cc_api_error(self.T, "rate_limit", "temporary capacity issue")),
+                    side(cc_api_error(self.T, "overloaded")),
+                    side(cc_api_error(self.T, "invalid_request")),
+                    side(cc_api_error(self.T, None))):
+            self.assertIsNone(ar.classify_claude_sidechain(rec), rec.get("error"))
+
+    def test_a_real_reply_proves_service_and_nothing_else_does(self):
+        self.assertEqual(ar.classify_claude_sidechain(side_reply(self.T)), ("cancel", "sidechain"))
+        synthetic = side_reply(self.T, text="No response requested.")
+        synthetic["message"]["model"] = "<synthetic>"
+        for rec in (synthetic, side(cc_user(self.T, "please continue")),
+                    side(cc_user(self.T, [{"type": "tool_result", "tool_use_id": "toolu_1",
+                                           "content": "ok"}])),
+                    queue_op(self.T), {"type": "system", "timestamp": iso(self.T)}, "x", None):
+            self.assertIsNone(ar.classify_claude_sidechain(rec), rec)
+        # in the MAIN transcript a sidechain record stays ignored, as before
+        self.assertIsNone(ar.classify_claude(side_quota(self.T, self.T + 60)))
+
+    def test_agent_names_and_the_newest_reply(self):
+        path = "/p/agent-%s.jsonl" % AGENT2
+        self.assertEqual(ar.sidechain_agent(side_reply(self.T), path), AGENT)
+        self.assertEqual(ar.sidechain_agent({"agentId": "a b\n"}, path), AGENT2)
+        self.assertEqual(ar.sidechain_agent({}, "/p/agent-../../x.jsonl"), "-")
+        lines = main_lines([side_reply(self.T + 1, text="first"),
+                            side_quota(self.T + 2, self.T + 60),
+                            side_reply(self.T + 3, text="last"),
+                            side(cc_user(self.T + 4, "tool output"))])
+        at, rec = ar.newest_answer(lines, ar.side_answer_at)
+        self.assertEqual((at, rec["timestamp"]), (self.T + 3.009, iso(self.T + 3)))
+        self.assertIsNone(ar.newest_answer(lines[1:2], ar.side_answer_at))
+        # found behind any run of lines that are none (a real main transcript had 193 in a
+        # row), and a line without the mark every reply holds is never even parsed
+        blobs = main_lines([request_blob()]) * 200
+        quiet = main_lines([side(tool_result(self.T + 5))]) * 50
+        with mock.patch.object(ar, "read_json_line", wraps=ar.read_json_line) as parse:
+            at, rec = ar.newest_answer(lines[:1] + blobs + quiet, ar.side_answer_at)
+        self.assertEqual((rec["timestamp"], parse.call_count), (iso(self.T + 1), 201))
+
+    def test_a_reply_answers_from_when_its_request_was_sent(self):
+        sent = {}
+        for rec in (api_request(self.T + 10, "req_1", AGENT),
+                    api_request(self.T + 30, "req_2", AGENT)):
+            ar.note_request(rec, sent)
+        self.assertEqual(sent, {"req_1": self.T + 10.009, "req_2": self.T + 30.009})
+        self.assertEqual(ar.claude_served_at(side_reply(self.T + 25, ref="req_1"), sent),
+                         self.T + 10.009)
+        # a request not on record (an older client names none) leaves the reply's own time
+        for ref in (None, "req_9", ["req_1"]):
+            rec = side_reply(self.T + 25)
+            rec["requestRef"] = ref
+            self.assertEqual(ar.claude_served_at(rec, sent), self.T + 25.009, ref)
+        self.assertEqual(ar.claude_served_at(side_reply(self.T + 25, ref="req_1")), self.T + 25.009)
+        self.assertIsNone(ar.side_answer_at(side_quota(self.T + 25, self.T + 60), sent))
+        # the newest ones are kept
+        with mock.patch.object(ar, "REQUESTS_KEPT", 2):
+            ar.note_request(api_request(self.T + 40, "req_3"), sent)
+            ar.note_request({"type": "api-request", "id": "req_4"}, sent)  # undated: nothing
+        self.assertEqual(sorted(sent), ["req_2", "req_3"])
+
+    def test_the_latest_answer_is_not_always_the_last_line(self):
+        # a prompt typed while a stream ran: the reply, written last, answers from its request
+        sent = {"req_1": self.T + 10.009}
+        tr = ar.ClaudeTracker(self.T - 100)
+        tr.requests = sent
+        lines = main_lines([cc_user(self.T + 15, "also check the docs"),
+                            main_reply(self.T + 40, "req_1")])
+        at, rec = ar.newest_answer(lines, lambda r: tr.answer_at(ar.classify_claude(r), r),
+                                   ar.ANSWER_MARKS)
+        self.assertEqual((at, rec["type"]), (self.T + 15.009, "user"))
+        # and the scan ends at the first record written before the best moment found
+        earlier = main_lines([side_reply(self.T - 100 + i) for i in range(100)])
+        turn = main_lines([api_request(self.T + 200, "req_x", AGENT)]
+                          + [side_reply(self.T + 201 + i, ref="req_x") for i in range(3)])
+        with mock.patch.object(ar, "read_json_line", wraps=ar.read_json_line) as parse:
+            at, _rec = ar.newest_answer(earlier + turn,
+                                        lambda r: ar.side_answer_at(r, {"req_x": self.T + 200.009}))
+        self.assertEqual((at, parse.call_count), (self.T + 200.009, 4))
+
+
+class SidechainTrackerTests(unittest.TestCase):
+    LAUNCHED = 1792440000
+
+    def tracker(self):
+        return ar.ClaudeTracker(self.LAUNCHED - 2)
+
+    def test_a_rejection_must_prove_it_is_from_this_launch(self):
+        tr = self.tracker()
+        self.assertIsNone(tr.feed_side(side_quota(self.LAUNCHED - 3, self.LAUNCHED + 99), 1))
+        undated = side_quota(self.LAUNCHED + 5, self.LAUNCHED + 99)
+        del undated["timestamp"]
+        self.assertIsNone(tr.feed_side(undated, 1))
+        self.assertIsNone(tr.pending)
+        ev = tr.feed_side(side_quota(self.LAUNCHED + 5, self.LAUNCHED + 99), 7, AGENT)
+        self.assertEqual(ev[0], "error")
+        self.assertEqual((tr.pending["class"], tr.pending["src"], tr.pending["agent"],
+                          tr.pending_since), ("quota", "sidechain", AGENT, 7))
+        # an old reply proves nothing new
+        self.assertIsNone(tr.feed_side(side_reply(self.LAUNCHED - 60), 8))
+        self.assertIsNotNone(tr.pending)
+
+    def test_the_replaced_processs_agents_never_reject_for_this_launch(self):
+        # A relaunch replaces a process whose workflow agents met the limit until it was gone,
+        # inside the second the shim's floored `date +%s` names as this launch (since is
+        # launched - 2): only a rejection from a second past the launch is this launch's own.
+        for offset in (-2, -1, 0):
+            tr = self.tracker()
+            self.assertIsNone(tr.feed_side(side_quota(self.LAUNCHED + offset, self.LAUNCHED + 99),
+                                           1), offset)
+            self.assertIsNone(tr.pending)
+        tr = self.tracker()
+        self.assertEqual(tr.feed_side(side_quota(self.LAUNCHED + 1, self.LAUNCHED + 99), 1)[0],
+                         "error")
+        # its replies still answer, and the main thread keeps its two seconds of slack
+        tr = self.tracker()
+        tr.feed_side(side_reply(self.LAUNCHED - 1), 1)
+        self.assertEqual(tr.cleared, self.LAUNCHED - 0.991)
+        self.assertEqual(tr.feed(cc_quota(self.LAUNCHED - 1, resets=self.LAUNCHED + 99), 2)[0],
+                         "error")
+
+    def test_a_reply_to_a_request_sent_before_the_rejection_answers_nothing(self):
+        launched = self.LAUNCHED
+        sent = {}
+        for rec in (api_request(launched + 10, "req_1", AGENT2),
+                    api_request(launched + 30, "req_2", AGENT2)):
+            ar.note_request(rec, sent)
+        rejection = side_quota(launched + 20, launched + 9000)
+        # a stream the account accepted before the limit, ending after it
+        streamed = final_answer(launched + 25, AGENT2, "req_1")
+        tr = self.tracker()
+        tr.feed_side(rejection, 1)
+        self.assertIsNone(tr.feed_side(streamed, 2, AGENT2, sent))
+        self.assertEqual((tr.pending["class"], tr.cleared), ("quota", launched + 10.009))
+        tr = self.tracker()  # read first, it answers nothing either
+        self.assertIsNone(tr.feed_side(streamed, 1, AGENT2, sent))
+        self.assertEqual(tr.feed_side(rejection, 2)[0], "error")
+        # a request sent after the limit, and served, is the answer
+        tr = self.tracker()
+        tr.feed_side(rejection, 1)
+        self.assertEqual(tr.feed_side(side_reply(launched + 40, AGENT2, ref="req_2"), 2, AGENT2,
+                                      sent), ("cancel", "sidechain"))
+        # with no request on record the reply's own time counts, as with older clients
+        tr = self.tracker()
+        tr.feed_side(rejection, 1)
+        self.assertEqual(tr.feed_side(streamed, 2, AGENT2), ("cancel", "sidechain"))
+
+    def test_the_main_threads_reply_counts_from_its_request_too(self):
+        launched = self.LAUNCHED
+        tr = self.tracker()
+        self.assertIsNone(tr.feed(api_request(launched + 10, "req_m1"), 1))
+        tr.feed_side(side_quota(launched + 20, launched + 9000), 1)
+        self.assertIsNone(tr.feed(main_reply(launched + 25, "req_m1"), 2))
+        self.assertEqual((tr.pending["class"], tr.cleared), ("quota", launched + 10.009))
+        tr.feed(api_request(launched + 30, "req_m2"), 3)
+        self.assertEqual(tr.feed(main_reply(launched + 40, "req_m2"), 4), ("cancel", "assistant"))
+        # what the prefilter skips the same way: request records are read, nothing else
+        tr, passed = self.tracker(), []
+        for raw in main_lines([cc_user(launched + 5, "write the section"),
+                               api_request(launched + 10, "req_m1"),
+                               main_reply(launched + 25, "req_m1"), tool_result(launched + 26)]):
+            if tr.wants(raw):
+                self.assertIsNone(tr.feed(json.loads(raw), 1))
+            else:
+                passed.append(raw)
+        self.assertEqual((len(passed), sorted(tr.requests)), (3, ["req_m1"]))
+        tr.passed_over(passed)
+        self.assertEqual(tr.cleared, launched + 10.009)
+        self.assertEqual(tr.feed_side(side_quota(launched + 20, launched + 9000), 5)[0], "error")
+        # a new conversation starts with no requests on record
+        tr.reset()
+        self.assertEqual((tr.requests, tr.cleared), ({}, 0.0))
+
+    def test_only_a_newer_reply_cancels_and_order_of_reading_does_not_matter(self):
+        rej, ok = side_quota(self.LAUNCHED + 10, self.LAUNCHED + 99), side_reply(self.LAUNCHED + 11)
+        tr = self.tracker()  # the rejection read first, then the newer reply
+        tr.feed_side(rej, 1)
+        self.assertEqual(tr.feed_side(side_reply(self.LAUNCHED + 10), 2), None)  # not newer
+        self.assertEqual(tr.feed_side(ok, 2), ("cancel", "sidechain"))
+        self.assertIsNone(tr.pending)
+        tr = self.tracker()  # the newer reply read first: the rejection is answered already
+        self.assertIsNone(tr.feed_side(ok, 1))
+        self.assertIsNone(tr.feed_side(rej, 2))
+        self.assertIsNone(tr.pending)
+        # a rejection after that reply stands again
+        self.assertEqual(tr.feed_side(side_quota(self.LAUNCHED + 12, self.LAUNCHED + 99), 3)[0],
+                         "error")
+
+    def test_the_newest_subagent_verdict_wins_and_a_repeat_changes_nothing(self):
+        tr = self.tracker()
+        first = side_quota(self.LAUNCHED + 10, self.LAUNCHED + 99)
+        tr.feed_side(first, 1, AGENT)
+        pending = tr.pending
+        # another agent meets the same limit later: the same verdict, still standing
+        self.assertIsNone(tr.feed_side(side_quota(self.LAUNCHED + 20, self.LAUNCHED + 99,
+                                                  AGENT2), 5, AGENT2))
+        self.assertIs(tr.pending, pending)
+        self.assertEqual((tr.pending["at"], tr.pending["agent"], tr.pending_since),
+                         (self.LAUNCHED + 20.009, AGENT, 1))
+        # ...so a reply between the two rejections answers only the first
+        self.assertIsNone(tr.feed_side(side_reply(self.LAUNCHED + 15), 6))
+        self.assertIs(tr.pending, pending)
+        # an older verdict read late never replaces a newer one; a newer class does
+        auth = side(cc_api_error(self.LAUNCHED + 5, "authentication_failed"))
+        self.assertIsNone(tr.feed_side(auth, 7))
+        auth = side(cc_api_error(self.LAUNCHED + 30, "authentication_failed"), AGENT3)
+        self.assertEqual(tr.feed_side(auth, 8, AGENT3)[0], "error")
+        self.assertEqual((tr.pending["class"], tr.pending["agent"], tr.pending_since),
+                         ("auth", AGENT3, 8))
+
+    def test_the_main_threads_own_account_verdict_stands(self):
+        tr = self.tracker()
+        tr.feed(cc_api_error(self.LAUNCHED + 10, "authentication_failed"), 1)
+        main = tr.pending
+        self.assertIsNone(tr.feed_side(side_quota(self.LAUNCHED + 20, self.LAUNCHED + 99), 2))
+        self.assertIsNone(tr.feed_side(side_reply(self.LAUNCHED + 30), 3))  # nor cancels it
+        self.assertIs(tr.pending, main)
+        self.assertIsNone(tr.fallback)
+        # and a main-thread verdict replaces a subagent's
+        tr = self.tracker()
+        tr.feed_side(side_quota(self.LAUNCHED + 20, self.LAUNCHED + 99), 1)
+        tr.feed(cc_api_error(self.LAUNCHED + 21, "authentication_failed"), 2)
+        self.assertEqual((tr.pending["class"], tr.pending.get("src")), ("auth", None))
+        self.assertIsNone(tr.feed_side(side_reply(self.LAUNCHED + 40), 3))
+        self.assertEqual(tr.pending["class"], "auth")
+
+    def test_main_thread_cancels_only_what_they_postdate(self):
+        for rec in (cc_reply(self.LAUNCHED + 30), cc_user(self.LAUNCHED + 30, "stop, I'm on it")):
+            tr = self.tracker()
+            tr.feed_side(side_quota(self.LAUNCHED + 20, self.LAUNCHED + 99), 1)
+            older = dict(rec, timestamp=iso(self.LAUNCHED + 19))
+            self.assertIsNone(tr.feed(older, 2))
+            self.assertIsNotNone(tr.pending)
+            self.assertEqual(tr.feed(rec, 3)[0], "cancel")
+            self.assertIsNone(tr.pending)
+            # the main thread's answer, read first, answers a rejection read later
+            self.assertIsNone(tr.feed_side(side_quota(self.LAUNCHED + 25, self.LAUNCHED + 99), 4))
+            self.assertIsNone(tr.pending)
+        # the auto-resume prompt is no human
+        tr = self.tracker()
+        tr.feed_side(side_quota(self.LAUNCHED + 20, self.LAUNCHED + 99), 1)
+        self.assertIsNone(tr.feed(cc_user(self.LAUNCHED + 30, ar.resume_prompt("quota")), 2))
+        self.assertIsNotNone(tr.pending)
+
+    def test_a_new_conversation_forgets_what_answered_the_old_one(self):
+        tr = self.tracker()
+        tr.feed_side(side_reply(self.LAUNCHED + 50), 1)
+        tr.reset()
+        self.assertEqual(tr.feed_side(side_quota(self.LAUNCHED + 40, self.LAUNCHED + 99), 2)[0],
+                         "error")
+
+    def test_what_the_prefilter_passed_over_still_answers(self):
+        launched = self.LAUNCHED
+        tr = self.tracker()
+        lines = main_lines([cc_user(launched + 10, "run the workflow"),
+                            cc_reply(launched + 20, "Started it."),
+                            cc_user(launched + 590, "forget the workflow, do X"),
+                            cc_reply(launched + 600, "Doing X.")]
+                           + [request_blob()] * 200 + [tool_result(launched + 601),
+                                                        queue_op(launched + 602)])
+        self.assertFalse(any(tr.wants(raw) for raw in lines))  # nothing pending: all skipped
+        tr.passed_over(lines)
+        self.assertEqual(tr.cleared, launched + 600.009)
+        # an agent's rejection before that reply is answered, whenever it is read...
+        self.assertIsNone(tr.feed_side(side_quota(launched + 300, launched + 9000), 1))
+        self.assertIsNone(tr.pending)
+        # ...and one after it stands
+        self.assertEqual(tr.feed_side(side_quota(launched + 700, launched + 9000), 2)[0], "error")
+
+    def test_only_a_real_reply_or_the_user_typing_answers_there(self):
+        launched = self.LAUNCHED
+        later = (cc_slash(launched + 60) + cc_slash(launched + 61, "usage")
+                 + [synthetic(launched + 62), cc_user(launched + 63, ar.resume_prompt("quota")),
+                    tool_result(launched + 64), queue_op(launched + 65)])
+        for answer in (cc_reply(launched + 50), cc_user(launched + 50, "never mind the workflow")):
+            with self.subTest(answer=answer["type"]):
+                tr = self.tracker()
+                tr.passed_over(main_lines([answer] + later))
+                self.assertEqual(tr.cleared, launched + 50.009)
+        # an undated answer dates nothing, one from before the launch is not this launch's
+        undated = cc_reply(launched + 70)
+        del undated["timestamp"]
+        tr = self.tracker()
+        tr.passed_over(main_lines([cc_reply(launched - 60), undated] + later))
+        self.assertEqual(tr.cleared, 0.0)
+
+    def test_what_the_prefilter_passed_over_cancels_nothing(self):
+        # read in one go: a reply the prefilter skipped, then the main thread's own rejection
+        tr = self.tracker()
+        passed = []
+        for raw in main_lines([cc_reply(self.LAUNCHED + 10),
+                               cc_quota(self.LAUNCHED + 20, resets=self.LAUNCHED + 9000)]):
+            if tr.wants(raw):
+                tr.feed(json.loads(raw), 1)
+            else:
+                passed.append(raw)
+        tr.passed_over(passed)
+        self.assertEqual((tr.pending["class"], tr.cleared), ("quota", self.LAUNCHED + 10.009))
+
+    def test_a_slash_command_never_answers_the_accounts_rejection(self):
+        launched = self.LAUNCHED
+        tr = self.tracker()
+        tr.feed_side(side_quota(launched + 20, launched + 9000), 1)
+        pending = tr.pending
+        for rec in cc_slash(launched + 30) + [synthetic(launched + 31)]:
+            self.assertIsNone(tr.feed(rec, 2))
+        self.assertEqual((tr.pending, tr.cleared), (pending, 0.0))
+        self.assertEqual(tr.feed(cc_user(launched + 32, "stop, I'm on it"), 3), ("cancel", "user"))
+        # read before an older rejection, skipped or parsed, it answers that one neither
+        for parsed in (False, True):
+            tr = self.tracker()
+            if parsed:
+                for rec in cc_slash(launched + 30):
+                    tr.feed(rec, 1)
+            else:
+                tr.passed_over(main_lines(cc_slash(launched + 30)))
+            self.assertEqual(tr.feed_side(side_quota(launched + 20, launched + 9000), 2)[0],
+                             "error")
+
+    def test_a_command_that_can_fix_the_account_answers_its_rejection(self):
+        # /login after "Not logged in", /limit-reset after the limit: the user fixed the
+        # account, like a typed prompt; so does any command not known to leave it as it was
+        launched = self.LAUNCHED
+        for err, name in ((side(cc_api_error(launched + 20, "authentication_failed",
+                                             "Not logged in · Please run /login")), "login"),
+                          (side_quota(launched + 20, launched + 9000), "limit-reset"),
+                          (side_quota(launched + 20, launched + 9000), "extra-usage"),
+                          (side_quota(launched + 20, launched + 9000), "brand-new-command")):
+            with self.subTest(command=name):
+                tr = self.tracker()
+                tr.feed_side(err, 1)
+                for rec in cc_slash(launched + 30, name):
+                    tr.feed(rec, 2)
+                self.assertEqual((tr.pending, tr.cleared), (None, launched + 30.009))
+                tr = self.tracker()  # skipped by the prefilter, read before the rejection
+                tr.passed_over(main_lines(cc_slash(launched + 30, name)))
+                self.assertIsNone(tr.feed_side(err, 3))
+
+
+# A model's limit, as the main thread records it (claude 2.1.303): /model is how one handles it.
+def model_limit(ts):
+    return cc_api_error(ts, "rate_limit",
+                        "You've reached your Fable limit. Switch to another model to continue.")
+
+
+class LiftedFallbackLatestResetTests(unittest.TestCase):
+    """A quota verdict whose reset has passed is dropped; an agent's account verdict
+    outranks the main thread's model or transient one, which waits behind it until the main
+    thread itself moves on; several rejections of one class are marked with the latest
+    reset."""
+    L = 1792440000
+
+    def tracker(self):
+        return ar.ClaudeTracker(self.L - 2)
+
+    def test_a_quota_verdict_whose_reset_has_passed_is_dropped(self):
+        L, now = self.L, self.L + 600
+        tr = self.tracker()
+        self.assertIsNone(tr.feed(cc_quota(L + 10, resets=L + 300), now))   # main thread
+        self.assertIsNone(tr.pending)
+        self.assertEqual(tr.feed(cc_quota(L + 11), now)[0], "error")       # no reset: stands
+        self.assertIsNone(tr.pending["reset"])
+        tr = self.tracker()
+        self.assertEqual(tr.feed(cc_quota(L + 12, resets=L + 9000), now)[0], "error")
+        tr = self.tracker()
+        self.assertIsNone(tr.feed_side(side_quota(L + 20, L + 300), now))   # an agent's
+        self.assertIsNone(tr.pending)
+        self.assertEqual(tr.feed_side(side_quota(L + 21, L + 9000), now)[0], "error")
+        # one whose reset passes while it waits is dropped then (Watcher.decide)
+        self.assertEqual(tr.expire(L + 8999), (False, None))
+        self.assertEqual(tr.expire(L + 9000), (True, None))
+        self.assertIsNone(tr.pending)
+        # nothing but a quota verdict has a reset to pass
+        tr = self.tracker()
+        tr.feed(cc_api_error(L + 30, "authentication_failed"), now)
+        self.assertEqual(tr.expire(L + 10 ** 6), (False, None))
+        self.assertEqual(tr.pending["class"], "auth")
+
+    def test_an_agents_account_verdict_outranks_the_main_threads_model_or_transient_one(self):
+        L = self.L
+        mains = {"model": model_limit, "concurrents": cc_concurrents,
+                 "overloaded": lambda ts: cc_api_error(ts, "overloaded")}
+        for name, main in sorted(mains.items()):
+            for agent_first in (False, True):
+                with self.subTest(main=name, agent_first=agent_first):
+                    tr = self.tracker()
+                    if agent_first:
+                        self.assertEqual(tr.feed_side(side_quota(L + 5, L + 9000), 1, AGENT)[0],
+                                         "error")
+                        self.assertIsNone(tr.feed(main(L + 10), 2))
+                    else:
+                        self.assertEqual(tr.feed(main(L + 10), 1)[0], "error")
+                        self.assertEqual(tr.feed_side(side_quota(L + 20, L + 9000), 2, AGENT)[0],
+                                         "error")
+                    self.assertEqual((tr.pending["class"], tr.pending["src"], tr.pending["agent"],
+                                      tr.pending["reset"], tr.pending_since),
+                                     ("quota", "sidechain", AGENT, L + 9000, 1 + (not agent_first)))
+                    self.assertIn(tr.fallback["class"], ("model", "transient"))
+                    self.assertIsNone(tr.fallback.get("src"))
+                    # /model ends the model's limit or the failed turn, never the account's
+                    self.assertIsNone(tr.feed(cc_slash(L + 30)[1], 3))
+                    self.assertEqual((tr.pending["class"], tr.fallback), ("quota", None))
+        # an agent's failed login just the same
+        tr = self.tracker()
+        tr.feed(cc_api_error(L + 10, "overloaded"), 1)
+        tr.feed_side(side(cc_api_error(L + 20, "authentication_failed")), 2, AGENT2)
+        self.assertEqual((tr.pending["class"], tr.pending["agent"], tr.fallback["class"]),
+                         ("auth", AGENT2, "transient"))
+        # nothing waits behind a main-thread account verdict an agent's cannot outrank...
+        tr = self.tracker()
+        tr.feed(cc_api_error(L + 10, "authentication_failed"), 1)
+        tr.feed_side(side_quota(L + 20, L + 9000), 2)
+        self.assertEqual((tr.pending["class"], tr.fallback), ("auth", None))
+        # ...which outranks the main thread's own later throttle too
+        tr = self.tracker()
+        tr.feed(cc_quota(L + 10, resets=L + 9000), 1)
+        self.assertIsNone(tr.feed(cc_concurrents(L + 20), 2))
+        self.assertEqual((tr.pending["class"], tr.pending_since, tr.fallback["class"]),
+                         ("quota", 1, "transient"))
+        # a main-thread account verdict of the same class takes the agent's in
+        tr = self.tracker()
+        tr.feed(model_limit(L + 10), 1)
+        tr.feed_side(side_quota(L + 20, L + 9000, rtype="seven_day"), 2)
+        tr.feed(cc_quota(L + 25, resets=L + 3600), 3)
+        self.assertEqual((tr.pending["reset"], tr.pending["rtype"], tr.pending.get("src"),
+                          tr.fallback), (L + 9000, "seven_day", None, None))
+
+    def test_what_it_outranks_ends_with_the_main_threads_own_next_word(self):
+        L = self.L
+        # the user typing after both: neither stands
+        tr = self.tracker()
+        tr.feed(model_limit(L + 10), 1)
+        tr.feed_side(side_quota(L + 20, L + 9000), 2)
+        self.assertEqual(tr.feed(cc_user(L + 30, "use sonnet then"), 3), ("cancel", "user"))
+        self.assertEqual((tr.pending, tr.fallback), (None, None))
+        # an agent's reply to a request sent after the account's verdict answers the account
+        # alone: the main thread, still stopped, has its own verdict back
+        tr = self.tracker()
+        tr.feed(cc_concurrents(L + 10), 1)
+        main = tr.pending
+        tr.feed_side(side_quota(L + 20, L + 9000), 2)
+        self.assertEqual(tr.feed_side(side_reply(L + 25, AGENT2), 3, AGENT2), ("error", main))
+        self.assertEqual((tr.pending, tr.pending_since, tr.fallback), (main, 3, None))
+        self.assertEqual(tr.feed(cc_slash(L + 30)[1], 4), ("cancel", "command"))
+        self.assertIsNone(tr.pending)
+        # a main-thread reply to a request sent before the account's verdict ends the main
+        # thread's own verdict only
+        tr = self.tracker()
+        tr.feed(api_request(L + 5, "req_m1"), 1)
+        tr.feed(model_limit(L + 10), 1)
+        tr.feed_side(side_quota(L + 20, L + 9000), 2)
+        self.assertIsNone(tr.feed(main_reply(L + 25, "req_m1"), 3))
+        self.assertEqual((tr.pending["class"], tr.pending["src"], tr.fallback),
+                         ("quota", "sidechain", None))
+        # a quota verdict that lapses lets the one behind it stand...
+        tr = self.tracker()
+        tr.feed(cc_concurrents(L + 10), 1)
+        tr.feed_side(side_quota(L + 20, L + 900), 2, AGENT3)
+        self.assertEqual((tr.pending["class"], tr.fallback["class"]), ("quota", "transient"))
+        dropped, promoted = tr.expire(L + 900)
+        self.assertTrue(dropped)
+        self.assertIs(tr.pending, promoted)
+        self.assertEqual((promoted["class"], promoted.get("src"), tr.pending_since),
+                         ("transient", None, L + 900))
+        # ...unless the main thread moved on meanwhile
+        tr = self.tracker()
+        tr.feed(cc_concurrents(L + 10), 1)
+        tr.feed_side(side_quota(L + 20, L + 900), 2)
+        tr.feed(cc_slash(L + 30)[1], 3)
+        self.assertEqual(tr.expire(L + 900), (True, None))
+        self.assertIsNone(tr.pending)
+        # a new conversation forgets it
+        tr = self.tracker()
+        tr.feed(model_limit(L + 10), 1)
+        tr.feed_side(side_quota(L + 20, L + 9000), 2)
+        tr.reset()
+        self.assertIsNone(tr.fallback)
+
+    def test_one_classes_rejections_are_marked_with_the_latest_reset(self):
+        L = self.L
+        five, week = (L + 3600, "five_hour"), (L + 86400, "seven_day")
+        for first, second in ((five, week), (week, five)):
+            with self.subTest(first=first[1]):
+                # the main thread: the newest record stands, with the latest reset
+                tr = self.tracker()
+                tr.feed(cc_quota(L + 10, first[1], resets=first[0]), 1)
+                tr.feed(cc_quota(L + 20, second[1], resets=second[0]), 2)
+                self.assertEqual((tr.pending["reset"], tr.pending["rtype"], tr.pending["at"],
+                                  tr.pending_since), (L + 86400, "seven_day", L + 20.009, 1))
+                # agents, in either order of reading
+                for stamps in ((L + 10, L + 20), (L + 20, L + 10)):
+                    tr = self.tracker()
+                    tr.feed_side(side_quota(stamps[0], first[0], rtype=first[1]), 1, AGENT)
+                    self.assertIsNone(tr.feed_side(side_quota(stamps[1], second[0], AGENT2,
+                                                              rtype=second[1]), 2, AGENT2))
+                    self.assertEqual((tr.pending["reset"], tr.pending["rtype"], tr.pending["at"],
+                                      tr.pending["agent"]),
+                                     (L + 86400, "seven_day", L + 20.009, AGENT))
+                # an agent's later reset reaches the main thread's verdict too
+                tr = self.tracker()
+                tr.feed(cc_quota(L + 10, first[1], resets=first[0]), 1)
+                tr.feed_side(side_quota(L + 20, second[0], rtype=second[1]), 2)
+                self.assertEqual((tr.pending["reset"], tr.pending["rtype"], tr.pending.get("src")),
+                                 (L + 86400, "seven_day", None))
+        # a rejection with no reset takes nothing away
+        tr = self.tracker()
+        tr.feed(cc_quota(L + 10, resets=L + 3600), 1)
+        tr.feed(cc_quota(L + 20), 2)
+        self.assertEqual(tr.pending["reset"], L + 3600)
+
+
+# =====================================================================================
+# the watcher
+# =====================================================================================
+
+class SidechainWatcherTests(SidechainCase):
+    def test_a_workflow_agents_five_hour_limit_moves_the_idle_session(self):
+        reset = int(self.t0) + 7200
+        w, r = self.start(["--dangerously-skip-permissions", "fix the flaky test"])
+        self.agent_file([side_reply(self.launched + 3), side_quota(self.t0 - 1, reset)])
+        # a workflow's journal and an agent's metadata are no transcripts
+        wf = self.proj / SID / "subagents" / "workflows" / "wf_7f3a9c"
+        (wf / "journal.jsonl").write_text(compact([side_quota(self.t0 - 1, reset, AGENT2)]))
+        (wf / ("agent-%s.meta.json" % AGENT2)).write_text(compact([side_quota(self.t0 - 1, reset)]))
+        self.assertEqual(w.run(), 0)
+        prompt = ar.resume_prompt("quota")
+        self.assertEqual(len(r.probes), 1)
+        probe = r.probes[0]
+        self.assertGreaterEqual(probe["t"] - self.t0, 5.0)  # GRACE, as for the main thread
+        self.assertEqual(probe["argv"], [self.self_path, "--dangerously-skip-permissions",
+                                         "--resume", SID, prompt])
+        self.assertEqual(probe["env"]["CLAUDE_MULTIACC_AR_AVOID"], "acct-01:%d" % reset)
+        self.assertEqual(r.signals, [(self.PID, signal.SIGTERM)])
+        self.assert_sequence(r)
+        kv, argv = self.relaunch_of(r)
+        self.assertEqual(argv, ["--dangerously-skip-permissions", "--resume", SID, prompt])
+        self.assertEqual({k: kv[k] for k in ("class", "acct", "reset", "rtype", "marked", "sid",
+                                             "depth", "avoid")},
+                         {"class": "quota", "acct": "acct-01", "reset": str(reset),
+                          "rtype": "five_hour", "marked": ar.utc_iso(self.t0 - 1), "sid": SID,
+                          "depth": "1", "avoid": "acct-01:%d" % reset})
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+        self.assertIn(" autoresume detect provider=claude chain=%s class=quota code=rate_limit "
+                      "sid=%s acct=acct-01 reset=%d src=sidechain agent=%s"
+                      % (kv["chain"], SID, reset, AGENT), self.log_lines()[1])
+        for line in self.log_lines():
+            self.assertEqual(line.split()[1], "autoresume")
+            self.assertNotIn("session limit", line)
+        self.assertEqual(sorted(os.path.basename(p) for p in w.side),
+                         ["agent-%s.jsonl" % AGENT])
+
+    def test_a_subagents_failed_login_moves_it_too(self):
+        w, r = self.start(["-c"])
+        self.agent_file([side(cc_api_error(self.t0, "authentication_failed",
+                                           "Not logged in · Please run /login"))], workflow=None)
+        w.run()
+        until = int(r.probes[0]["t"]) + 3600
+        self.assertEqual(r.probes[0]["env"]["CLAUDE_MULTIACC_AR_AVOID"], "acct-01:%d" % until)
+        kv, argv = self.relaunch_of(r)
+        self.assertEqual(argv, ["--resume", SID, ar.resume_prompt("auth")])
+        self.assertEqual((kv["class"], kv["reset"], kv["rtype"]), ("auth", "", ""))
+        self.assertIn("class=auth code=authentication_failed", self.log_lines()[1])
+        self.assertIn("src=sidechain agent=%s" % AGENT, self.log_lines()[1])
+
+    def test_an_organization_refusal_in_a_subagent_parks_like_the_main_threads(self):
+        w, r = self.start([])
+        self.agent_file([side(cc_api_error(self.t0, "oauth_org_not_allowed"))])
+        w.run()
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["rtype"]), ("blocked", "oauth_org_not_allowed"))
+
+    def test_a_subagents_own_model_transient_or_other_errors_never_move_it(self):
+        w, r = self.start([])
+        self.agent_file([side_quota(self.t0, int(self.t0) + 999, rtype="seven_day_opus"),
+                         side(cc_api_error(self.t0, "rate_limit",
+                                           "You've reached your Fable limit. Switch models")),
+                         side(cc_api_error(self.t0, "overloaded")),
+                         side(cc_api_error(self.t0, "invalid_request", "bad tool schema")),
+                         side(cc_user(self.t0 + 1, "carry on"))])
+        self.stop_at(r, self.t0 + 30)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])  # not even a `never` line
+
+    def test_a_rejection_from_before_the_launch_never_fires(self):
+        # a resumed conversation's agents met a limit in an earlier launch
+        w, r = self.start(["--resume", SID])
+        self.agent_file([side_quota(self.launched - 3, int(self.t0) + 999)])
+        self.stop_at(r, self.t0 + 20)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])
+
+    def test_a_transcript_last_written_before_the_launch_is_followed_from_its_end(self):
+        reset = int(self.t0) + 999
+        # mis-dated on purpose: were this file read from its start, the rejection would count
+        path = self.agent_file([side_quota(self.t0, reset)], mtime=self.launched - 60)
+        w, r = self.start([])
+        size = path.stat().st_size
+        r.at(self.t0 + 10, lambda: fixtures.append(path, [side_quota(self.t0 + 10, reset)]))
+        self.assertEqual(w.run(), 0)
+        self.assertGreaterEqual(r.probes[0]["t"], self.t0 + 15)
+        self.assertGreater(self.tail_of(w, path.name).off, size)
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["marked"]), ("quota", ar.utc_iso(self.t0 + 10)))
+
+    def test_a_later_reply_of_that_agent_or_another_cancels(self):
+        for later in (AGENT, AGENT2):
+            with self.subTest(agent=later):
+                log = self.root / "selection.log"
+                if log.exists():
+                    log.unlink()
+                w, r = self.start([])
+                path = self.agent_file([side_quota(self.t0, int(self.t0) + 999)],
+                                       workflow="wf_" + later)
+                other = self.agent_file([side_reply(self.launched + 1, AGENT2)],
+                                        agent=AGENT2, workflow="wf_" + later + "x")
+                target = path if later == AGENT else other
+                r.at(self.t0 + 2, lambda target=target, later=later: fixtures.append(
+                    target, [side_reply(self.t0 + 2, later)]))
+                self.stop_at(r, self.t0 + 20)
+                self.assertEqual(w.run(), 0)
+                self.assert_untouched(r)
+                self.assertEqual(self.events(), ["watch", "detect"])
+                for p in (path, other):
+                    p.unlink()
+
+    def test_a_later_main_thread_reply_or_the_user_typing_cancels(self):
+        for rec in (cc_reply(self.t0 + 2, "The workflow finished; all green."),
+                    cc_user(self.t0 + 2, "never mind the workflow, look at this")):
+            with self.subTest(type=rec["type"]):
+                w, r = self.start([])
+                tpath = self.proj / (SID + ".jsonl")
+                agent = self.agent_file([side_quota(self.t0, int(self.t0) + 999)])
+                r.at(self.t0 + 2, lambda rec=rec: fixtures.append(tpath, [rec]))
+                self.stop_at(r, self.t0 + 20)
+                self.assertEqual(w.run(), 0)
+                self.assert_untouched(r)
+                for path in (tpath, agent):
+                    path.unlink()
+
+    def test_main_thread_words_older_than_the_rejection_do_not_cancel(self):
+        # written (or read) late, a reply from before the rejection answers nothing
+        w, r = self.start([])
+        tpath = self.proj / (SID + ".jsonl")
+        self.agent_file([side_quota(self.t0, int(self.t0) + 999)])
+        r.at(self.t0 + 2, lambda: fixtures.append(tpath, [cc_reply(self.t0 - 1, "earlier"),
+                                                          cc_user(self.t0 - 1, "earlier")]))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+
+    def test_an_answered_rejection_never_fires_whichever_file_is_read_first(self):
+        reset = int(self.t0) + 999
+        w, r = self.start([])
+        # one agent was rejected; another got a reply after that (the limit had reset)
+        self.agent_file([side_quota(self.t0 - 2, reset)], workflow="wf_b")
+        self.agent_file([side_reply(self.t0 - 1, AGENT2)], agent=AGENT2, workflow="wf_a")
+        self.stop_at(r, self.t0 + 20)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])  # never even shown as pending
+
+    def test_many_agents_meeting_the_same_limit_probe_once(self):
+        reset = int(self.t0) + 999
+        w, r = self.start([])
+        path = self.agent_file([side_quota(self.t0 - 1, reset)])
+        self.agent_file([side_quota(self.t0 - 0.5, reset, AGENT2)], agent=AGENT2,
+                        workflow="wf_2")
+        real_run = r.run
+
+        def run(argv, timeout, env=None, cwd=None):
+            if argv[0] == self.self_path:  # one more agent is rejected during the probe
+                fixtures.append(path, [side_quota(self.t0 + 5, reset)])
+            return real_run(argv, timeout, env, cwd)
+        r.run = run
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual(kv["marked"], ar.utc_iso(self.t0 - 1))
+
+    def test_a_reply_during_the_probe_wins(self):
+        w, r = self.start([])
+        path = self.agent_file([side_quota(self.t0, int(self.t0) + 999)])
+        real_run = r.run
+
+        def run(argv, timeout, env=None, cwd=None):
+            if argv[0] == self.self_path and not r.probes:
+                fixtures.append(path, [side_reply(self.t0 + 5)])
+            return real_run(argv, timeout, env, cwd)
+        r.run = run
+        self.stop_at(r, self.t0 + 20)
+        w.run()
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+
+    def test_no_room_holds_like_the_main_thread(self):
+        w, r = self.start([], env={"CLAUDE_MULTIACC_AR_HOLD_REPROBE": "5"})
+        self.agent_file([side_quota(self.t0, int(self.t0) + 999)])
+        r.probe_out = "pick=acct-01 tier=soft\n"
+        self.stop_at(r, self.t0 + 16.5)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 3)
+        self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+        self.assertEqual(self.events(), ["watch", "detect", "hold"])
+
+    def test_the_replaced_processs_last_rejections_never_move_the_relaunch(self):
+        # The watcher of a RELAUNCHED session (on acct-01, the account it moved to). The process
+        # it replaced ran a workflow whose agents kept meeting the old account's limit, in a
+        # burst, until it was gone: inside the second `date +%s` floored to this launch.
+        reset = int(self.t0) + 9000
+        for later in (False, True):
+            with self.subTest(own_agent_rejected_later=later):
+                log = self.root / "selection.log"
+                if log.exists():
+                    log.unlink()
+                launched = self.launched = int(self.t0) - 1
+                state = self.write_state(["--dangerously-skip-permissions", "--resume", SID],
+                                         depth=1, avoid="acct-02:%d" % reset)
+                self.registry()
+                tpath = self.transcript([cc_user(launched - 3600, "run the release workflow"),
+                                         cc_reply(launched - 3590, "Started it; waiting for it."),
+                                         cc_user(launched + 1, ar.resume_prompt("quota"))])
+                old = [self.agent_file([side_reply(launched - 400),
+                                        side_quota(launched - 2, reset)], mtime=launched - 2),
+                       self.agent_file([side_reply(launched - 60, AGENT2),
+                                        side_quota(launched - 1, reset, AGENT2)],
+                                       agent=AGENT2, workflow="wf_2", mtime=launched - 1),
+                       self.agent_file([side_quota(launched, reset, AGENT3)], agent=AGENT3,
+                                       workflow="wf_3", mtime=launched)]
+                w, r = self.watcher(state)
+                r.probe_out = "pick=acct-03 tier=eligible\n"
+                # the resumed conversation's first reply is slow (a cold cache on this account)
+                r.at(self.t0 + 12, lambda tpath=tpath: fixtures.append(
+                    tpath, [cc_reply(self.t0 + 12, "Picking up where it left off.")]))
+                if later:  # this launch's own agent meets a limit: that one counts
+                    r.at(self.t0 + 20, lambda: write(old[2], [side_quota(self.t0 + 20, reset,
+                                                                          AGENT3)]))
+                self.stop_at(r, self.t0 + 40)
+                self.assertEqual(w.run(), 0)
+                if later:
+                    self.assertEqual(len(r.probes), 1)
+                    self.assertEqual(self.events(), ["watch", "detect", "switch"])
+                    self.assertEqual(self.relaunch_of(r)[0]["marked"], ar.utc_iso(self.t0 + 20))
+                else:
+                    self.assert_untouched(r)
+                    self.assertEqual(self.events(), ["watch"])
+                for path in old + [tpath]:
+                    path.unlink()
+
+    def test_a_reply_the_account_accepted_before_the_limit_answers_nothing(self):
+        # One agent's stream ran on past another agent's rejection (by minutes in session
+        # 5526ddd6, 2026-10-19). Here it is that agent's final answer: the workflow then waits
+        # for the rejected one, and nothing more is written.
+        reset = int(self.t0) + 9000
+        w, r = self.start([])
+        self.agent_file([side_reply(self.launched + 3), side_quota(self.t0 - 1, reset)])
+        other = self.agent_file([api_request(self.launched + 3, "req_b1", AGENT2),
+                                 side_reply(self.launched + 4, AGENT2, ref="req_b1"),
+                                 api_request(self.t0 - 30, "req_b2", AGENT2)],
+                                agent=AGENT2, workflow="wf_b")
+        r.at(self.t0 + 2, lambda: write(other, [final_answer(self.t0 + 2, AGENT2, "req_b2")]))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+        self.assertEqual(self.relaunch_of(r)[0]["marked"], ar.utc_iso(self.t0 - 1))
+
+    def test_a_reply_to_a_request_sent_after_the_limit_still_cancels(self):
+        w, r = self.start([])
+        self.agent_file([side_quota(self.t0 - 1, int(self.t0) + 9000)])
+        other = self.agent_file([api_request(self.t0 - 30, "req_b1", AGENT2)], agent=AGENT2,
+                                workflow="wf_b")
+        # the limit is lifted (a reset), the agent's next request is served
+        r.at(self.t0 + 1, lambda: write(other, [final_answer(self.t0 + 1, AGENT2, "req_b1"),
+                                                 api_request(self.t0 + 1, "req_b2", AGENT2)]))
+        r.at(self.t0 + 3, lambda: write(other, [side_reply(self.t0 + 3, AGENT2, ref="req_b2")]))
+        self.stop_at(r, self.t0 + 30)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch", "detect"])
+
+    def test_a_command_that_fixes_the_account_keeps_the_session(self):
+        # /login after the agents' "Not logged in"; /limit-reset while the watcher holds the
+        # agents' limit for want of room, before room appears
+        for err, name, hold in ((side(cc_api_error(self.t0, "authentication_failed",
+                                                    "Not logged in · Please run /login")),
+                                 "login", False),
+                                (side_quota(self.t0, int(self.t0) + 9000), "limit-reset", True)):
+            with self.subTest(command=name):
+                log = self.root / "selection.log"
+                if log.exists():
+                    log.unlink()
+                w, r = self.start([], env={"CLAUDE_MULTIACC_AR_HOLD_REPROBE": "10"})
+                tpath = self.proj / (SID + ".jsonl")
+                agent = self.agent_file([err])
+                at = self.t0 + (8 if hold else 2)
+                if hold:
+                    r.probe_out = "pick=acct-01 tier=soft\n"
+                    r.at(self.t0 + 9, lambda r=r: setattr(r, "probe_out",
+                                                          "pick=acct-02 tier=eligible\n"))
+                r.at(at, lambda at=at, name=name: fixtures.append(tpath, cc_slash(at, name)))
+                self.stop_at(r, self.t0 + 40)
+                self.assertEqual(w.run(), 0)
+                self.assertEqual((len(r.probes), r.signals, r.sends, self.relaunch_files()),
+                                 (int(hold), [], [], []))
+                self.assertEqual(self.events(), ["watch", "detect"] + ["hold"] * hold)
+                for path in (tpath, agent):
+                    path.unlink()
+
+    def test_a_session_change_resets_the_subagent_tails(self):
+        reset = int(self.t0) + 999
+        w, r = self.start([])
+        old = self.agent_file([side_quota(self.t0, reset)])
+        self.transcript([cc_user(self.t0 + 1, "a new task")], sid=SID2)
+        # /clear before GRACE: the old conversation's agents are no longer this session's
+        r.at(self.t0 + 1.5, lambda: self.registry(sid=SID2))
+        r.at(self.t0 + 3, lambda: fixtures.append(old, [side_quota(self.t0 + 3, reset)]))
+        r.at(self.t0 + 20, lambda: self.agent_file([side_quota(self.t0 + 20, reset)], sid=SID2))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertGreaterEqual(r.probes[0]["t"], self.t0 + 25)
+        kv, argv = self.relaunch_of(r)
+        self.assertEqual((kv["sid"], argv[-2]), (SID2, SID2))
+        self.assertEqual(self.events(), ["watch", "detect", "detect", "switch"])
+        self.assertTrue(w.side and all(SID2 in path and SID not in path for path in w.side))
+
+
+class LiftedFallbackLatestResetWatcherTests(SidechainCase):
+    def fresh(self):
+        for path in [self.root / "selection.log", self.proj / (SID + ".jsonl")] \
+                + list((self.proj / SID).glob("subagents/**/agent-*.jsonl")):
+            if path.exists():
+                path.unlink()
+
+    def test_a_limit_that_has_reset_already_moves_nothing(self):
+        # a watcher that reads a rejection only once its reset has passed (restarted onto
+        # the session, or a slow replay): the account serves again
+        for where in ("main", "agent"):
+            with self.subTest(where=where):
+                self.fresh()
+                main = [cc_user(self.launched + 1, "go"), cc_reply(self.launched + 2, "ok")]
+                if where == "main":
+                    main.append(cc_quota(self.t0 - 2, resets=int(self.t0) - 1))
+                w, r = self.start([], main=main)
+                if where == "agent":
+                    self.agent_file([side_quota(self.t0 - 2, int(self.t0) - 1)])
+                self.stop_at(r, self.t0 + 20)
+                self.assertEqual(w.run(), 0)
+                self.assert_untouched(r)
+                self.assertEqual(self.events(), ["watch"])
+
+    def test_a_verdict_whose_reset_passes_in_a_hold_is_dropped(self):
+        reset = int(self.t0) + 9
+        for where in ("main", "agent"):
+            with self.subTest(where=where):
+                self.fresh()
+                main = [cc_user(self.launched + 1, "go"), cc_reply(self.launched + 2, "ok")]
+                if where == "main":
+                    main.append(cc_quota(self.t0, resets=reset))
+                w, r = self.start([], main=main, env={"CLAUDE_MULTIACC_AR_HOLD_REPROBE": "2"})
+                if where == "agent":
+                    self.agent_file([side_quota(self.t0, reset)])
+                r.probe_out = "pick=acct-01 tier=soft\n"  # nowhere to go: hold
+                r.at(self.t0 + 12, lambda r=r: setattr(r, "probe_out",
+                                                       "pick=acct-02 tier=eligible\n"))
+                self.stop_at(r, self.t0 + 30)
+                self.assertEqual(w.run(), 0)
+                self.assertTrue(r.probes)
+                self.assertTrue(all(p["t"] < reset for p in r.probes), r.probes)
+                self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+                self.assertEqual(self.events(), ["watch", "detect", "hold"])
+
+    def test_model_ends_the_main_threads_model_verdict_but_not_the_agents_limit(self):
+        reset = int(self.t0) + 7200
+        w, r = self.start([], main=[cc_user(self.launched + 1, "run the release workflow"),
+                                    cc_reply(self.launched + 2, "Started it."),
+                                    model_limit(self.t0)])
+        self.agent_file([side_quota(self.t0, reset)])
+        tpath = self.proj / (SID + ".jsonl")
+        r.at(self.t0 + 2, lambda: fixtures.append(tpath, cc_slash(self.t0 + 2)))
+        self.stop_at(r, self.t0 + 40)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        # the agent's verdict outranked the model's from the start: its grace is its own
+        self.assertGreaterEqual(r.probes[0]["t"], self.t0 + 5)
+        self.assertLess(r.probes[0]["t"], self.t0 + 7)
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["reset"], kv["rtype"]),
+                         ("quota", str(reset), "five_hour"))
+        self.assertEqual(self.events(), ["watch", "detect", "detect", "switch"])
+        detects = [line for line in self.log_lines() if line.split()[2] == "detect"]
+        self.assertIn("class=model", detects[0])
+        self.assertIn("class=quota", detects[1])
+        self.assertIn("src=sidechain agent=%s" % AGENT, detects[1])
+
+    def test_agents_meeting_the_limit_move_a_session_its_throttled_main_thread_held(self):
+        # 2026-10-20, session 6: the main thread's "concurrents" rejection (read as a model's
+        # limit) waited on its busy agents while, from three minutes later, they were all
+        # meeting the five-hour limit; the session moved six minutes after that rejection
+        reset = int(self.t0) + 9000
+        w, r = self.start([], main=[cc_user(self.launched + 1, "run the i18n workflows"),
+                                    cc_reply(self.launched + 2, "Started them."),
+                                    cc_concurrents(self.t0)])
+        self.agent_file([side_reply(self.launched + 3, AGENT2)], agent=AGENT2,
+                        workflow="wf_2", mtime=self.t0 + 900)  # writing all along
+        path = self.agent_file([side_reply(self.launched + 3)])
+        r.at(self.t0 + 180, lambda: fixtures.append(path, [side_quota(self.t0 + 180, reset)]))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertGreaterEqual(r.probes[0]["t"], self.t0 + 185)
+        self.assertLess(r.probes[0]["t"], self.t0 + 195)  # its grace, not the agents' quiet
+        kv, argv = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["reset"], kv["rtype"]),
+                         ("quota", str(reset), "five_hour"))
+        self.assertEqual(argv, ["--resume", SID, ar.resume_prompt("quota")])
+        self.assertEqual(self.events(), ["watch", "detect", "detect", "switch"])
+        detects = [line for line in self.log_lines() if line.split()[2] == "detect"]
+        self.assertIn("class=transient code=rate_limit", detects[0])
+        self.assertIn("class=quota", detects[1])
+        self.assertIn("src=sidechain agent=%s" % AGENT, detects[1])
+
+    def test_a_throttled_main_thread_waits_for_its_working_agents_and_keeps_the_account(self):
+        w, r = self.start([], main=[cc_user(self.launched + 1, "run the i18n workflows"),
+                                    cc_reply(self.launched + 2, "Started them."),
+                                    cc_concurrents(self.t0)])
+        self.agent_file([side_reply(self.launched + 3)], mtime=self.t0 + 100)  # until ~t0+100
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertGreaterEqual(r.probes[0]["t"], self.t0 + 120)  # 20 s of agent quiet
+        self.assertEqual(r.probes[0]["env"]["CLAUDE_MULTIACC_AR_AVOID"], "")  # nothing avoided
+        kv, argv = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["avoid"]), ("transient", ""))
+        self.assertEqual(argv, ["--resume", SID, ar.resume_prompt("transient")])
+
+    def test_the_latest_reset_of_one_limit_is_the_one_marked(self):
+        five, week = int(self.t0) + 3600, int(self.t0) + 86400
+        w, r = self.start([])
+        # the weekly limit, met first, sits in the transcript read second
+        self.agent_file([side_quota(self.t0 - 1, week, rtype="seven_day")], mtime=self.t0 - 2)
+        self.agent_file([side_quota(self.t0 - 0.5, five, AGENT2)], agent=AGENT2,
+                        workflow="wf_2", mtime=self.t0 - 1)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["reset"], kv["rtype"]),
+                         ("quota", str(week), "seven_day"))
+
+
+class SidechainReplayTests(SidechainCase):
+    """A watcher (re)started onto a live session reads everything written since its launch,
+    hours of it: an agent's old rejection must never stop a session served since."""
+
+    def setUp(self):
+        super().setUp()
+        self.launched = int(self.t0) - 3600  # launched an hour ago; the watcher starts now
+
+    def restarted(self, main, agent=None):
+        state = self.write_state(["--dangerously-skip-permissions"])
+        self.registry()
+        self.transcript(main)
+        if agent:
+            self.agent_file(agent)
+        return self.watcher(state)
+
+    def replay(self, last_reply):
+        """Read 8 KB a tick: the rejected agent, written last (its re-run request is in
+        flight), comes first; a busy agent whose newest reply is ``last_reply`` is reached
+        only well after GRACE."""
+        w, r = self.restarted([cc_user(self.launched + 10, "run the workflow"),
+                               cc_reply(self.launched + 20, "Started it.")])
+        self.agent_file([side_quota(self.t0 - 1800, int(self.t0) + 9000), request_blob()],
+                        mtime=self.t0 - 60)
+        busy = [side_reply(self.launched + 100 + i, AGENT2, "x" * 900) for i in range(100)]
+        path = self.agent_file(busy + [side_reply(last_reply, AGENT2)], agent=AGENT2,
+                               workflow="wf_busy", mtime=self.t0 - 590)
+        self.assertGreater(path.stat().st_size, 10 * 8192)
+        return w, r
+
+    def test_a_rejection_waits_for_the_rest_of_the_replay(self):
+        w, r = self.replay(self.t0 - 600)  # served since the rejection
+        self.stop_at(r, self.t0 + 30)
+        with mock.patch.object(ar, "SIDE_BYTES", 8192):
+            self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch", "detect"])  # pending, then answered
+
+    def test_a_rejection_nothing_answers_still_moves_once_all_is_read(self):
+        w, r = self.replay(self.launched + 300)  # the busy agent's last reply came before it
+        real_run, unread = r.run, []
+
+        def run(argv, timeout, env=None, cwd=None):
+            if argv[0] == self.self_path:
+                unread.extend(p for p, t in w.side.items() if t.off != os.path.getsize(p))
+            return real_run(argv, timeout, env, cwd)
+        r.run = run
+        with mock.patch.object(ar, "SIDE_BYTES", 8192):
+            self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(unread, [])  # probed only once the whole replay was read
+        self.assertGreaterEqual(r.probes[0]["t"], self.t0 + 10)
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+
+    def test_a_main_thread_served_since_the_rejection_is_left_alone(self):
+        # 2026-10-19: a workflow agent rejected 30 min ago, the main thread replying since
+        w, r = self.restarted(
+            [cc_user(self.launched + 10, "run the workflow"),
+             api_request(self.launched + 11, "req_m1"),
+             main_reply(self.launched + 20, "req_m1", "Started it."),
+             cc_user(self.t0 - 600, "forget the workflow, do X"),
+             api_request(self.t0 - 599, "req_m2"),
+             main_reply(self.t0 - 590, "req_m2", "Doing X.")]
+            + [request_blob()] * 200 + [tool_result(self.t0 - 589)] + cc_slash(self.t0 - 60),
+            [side_reply(self.launched + 30), side_quota(self.t0 - 1800, int(self.t0) + 9000)])
+        self.stop_at(r, self.t0 + 30)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])  # never even pending
+
+    def test_a_main_thread_stream_that_spanned_the_rejection_still_moves(self):
+        # the main thread's last reply ended after the agents' limit, but the account had
+        # accepted its request before it; idle since
+        reset = int(self.t0) + 9000
+        w, r = self.restarted(
+            [cc_user(self.launched + 10, "run the workflow, then write the report"),
+             api_request(self.t0 - 1900, "req_m1"),
+             main_reply(self.t0 - 1700, "req_m1", "Report written; waiting for the workflow."),
+             queue_op(self.t0 - 1650)],
+            [side_reply(self.launched + 30), side_quota(self.t0 - 1800, reset)])
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+
+    def test_an_agents_stream_accepted_before_the_rejection_answers_nothing_on_replay(self):
+        reset = int(self.t0) + 9000
+        w, r = self.restarted([cc_user(self.launched + 10, "run the workflow"),
+                               cc_reply(self.launched + 20, "Started it."),
+                               queue_op(self.t0 - 1700)],
+                              [side_reply(self.launched + 30), side_quota(self.t0 - 1800, reset)])
+        self.agent_file([api_request(self.t0 - 1830, "req_b1", AGENT2),
+                         final_answer(self.t0 - 1500, AGENT2, "req_b1")], agent=AGENT2,
+                        workflow="wf_b")
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+
+    def test_a_prompt_typed_since_counts_while_its_reply_is_on_its_way(self):
+        w, r = self.restarted(
+            [cc_user(self.launched + 10, "run the workflow"),
+             cc_reply(self.launched + 20, "Started it."),
+             cc_user(self.t0 - 2, "the limit has reset, carry on")],
+            [side_quota(self.t0 - 1800, int(self.t0) + 9000)])
+        self.stop_at(r, self.t0 + 30)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])
+
+    def test_a_session_stuck_since_the_rejection_still_moves(self):
+        # sessions 5 and 8 as a restarted watcher reads them: the main thread's last reply
+        # came before the agents' limit; since then only the paused workflow's notices,
+        # /model, and words of the client's own
+        reset = int(self.t0) + 9000
+        w, r = self.restarted(
+            [cc_user(self.launched + 10, "run the workflow"),
+             cc_reply(self.launched + 20, "Started it; waiting for the workflow."),
+             queue_op(self.t0 - 1700)] + cc_slash(self.t0 - 600) + [synthetic(self.t0 - 599)],
+            [side_reply(self.launched + 30), side_quota(self.t0 - 1800, reset)])
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["reset"], kv["marked"]),
+                         ("quota", str(reset), ar.utc_iso(self.t0 - 1800)))
+
+    def test_an_agent_transcript_found_after_the_main_threads_answer_is_answered(self):
+        # whatever order things are read in: the reply was read (and skipped) first
+        w, r = self.start([], main=[cc_user(self.launched + 1, "run the release workflow"),
+                                    cc_reply(self.t0 - 2, "On it.")])
+        r.at(self.t0 + 6, lambda: self.agent_file([side_quota(self.t0 - 3, int(self.t0) + 999)]))
+        self.stop_at(r, self.t0 + 30)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])
+
+
+class SidechainDiscoveryTests(SidechainCase):
+    def test_new_agents_are_looked_for_every_subagent_scan_seconds(self):
+        w, r = self.start([], env={"CLAUDE_MULTIACC_AR_SUBAGENT_SCAN": "3"})
+        self.assertEqual(w.cfg.subagent_scan, 3.0)
+        self.assertEqual(ar.Config("claude", {}).subagent_scan, 5.0)
+        self.agent_file([side_reply(self.launched + 1)])
+        w.read()
+        self.assertEqual(len(w.side), 1)
+        later = self.agent_file([side_quota(self.t0, int(self.t0) + 999, AGENT2)],
+                                agent=AGENT2, workflow=None)
+        r.t += 2
+        w.read()
+        self.assertEqual((len(w.side), w.tracker.pending), (1, None))
+        r.t += 1
+        w.read()
+        self.assertEqual(self.tail_of(w, later.name).off, later.stat().st_size)
+        self.assertEqual(w.tracker.pending["agent"], AGENT2)
+
+    def test_only_the_most_recently_written_are_followed(self):
+        reset = int(self.t0) + 999
+        w, r = self.start([])
+        oldest = self.agent_file([side_quota(self.t0, reset)], workflow="wf_1",
+                                 mtime=self.launched + 1)
+        self.agent_file([side_reply(self.launched + 1, AGENT2)], agent=AGENT2,
+                        workflow="wf_2", mtime=self.launched + 2)
+        newest = self.agent_file([side_reply(self.launched + 1, AGENT3)], agent=AGENT3,
+                                 workflow="wf_3", mtime=self.launched + 3)
+        with mock.patch.object(ar, "SIDE_FILES", 2):
+            w.read()
+            self.assertEqual([os.path.basename(p) for p in w.side_order],
+                             [newest.name, "agent-%s.jsonl" % AGENT2])
+            self.assertIsNone(w.tracker.pending)
+            # the rejected agent writes again: it is among the newest, read from its start
+            fixtures.append(oldest, [side_quota(self.t0 + 1, reset)])
+            r.t += 5
+            w.read()
+            self.assertEqual([os.path.basename(p) for p in w.side_order],
+                             [oldest.name, newest.name])
+            self.assertEqual((w.tracker.pending["class"], w.tracker.pending["at"]),
+                             ("quota", self.t0 + 1.009))
+            # a file no longer followed keeps its place while it is there
+            self.assertEqual(self.tail_of(w, "agent-%s.jsonl" % AGENT2).off,
+                             (self.proj / SID / "subagents" / "workflows" / "wf_2" /
+                              ("agent-%s.jsonl" % AGENT2)).stat().st_size)
+
+    def test_the_walk_is_bounded(self):
+        w, r = self.start([])
+        for i in range(6):
+            self.agent_file([side_reply(self.launched + 1, "a%d" % i)], agent="a%d" % i,
+                            workflow="wf_%d" % i)
+        with mock.patch.object(ar, "SIDE_SCAN", 3):
+            w.read()
+        self.assertEqual(len(w.side), 3)
+
+    def test_the_bytes_read_per_tick_are_bounded(self):
+        reset = int(self.t0) + 999
+        w, r = self.start([])
+        filler = [side_reply(self.launched + 1 + i * 0.01, text="x" * 900) for i in range(60)]
+        big = self.agent_file(filler + [side_quota(self.t0, reset)])
+        small = self.agent_file([side_reply(self.launched + 1, AGENT2)], agent=AGENT2,
+                                workflow="wf_small")
+        reads = 0
+        with mock.patch.object(ar, "SIDE_BYTES", 8192):
+            while w.tracker.pending is None and reads < 100:
+                w.read()
+                reads += 1
+                self.assertLessEqual(sum(t.got for t in w.side.values()), 8192)
+        self.assertGreater(reads, big.stat().st_size // 8192)
+        self.assertEqual(w.tracker.pending["class"], "quota")
+        self.assertEqual(self.tail_of(w, small.name).off, small.stat().st_size)
+
+    def test_subagents_wait_for_the_main_transcript_to_be_caught_up(self):
+        main = [cc_reply(self.launched + 1, "y" * 2000) for _ in range(8)]
+        w, r = self.start([], main=main)
+        self.agent_file([side_quota(self.t0, int(self.t0) + 999)])
+        with mock.patch.object(ar.JsonlTail, "MAX_READ", 4096):
+            w.read()
+            self.assertGreater(w.tail.behind, 0)
+            self.assertEqual((w.side, w.tracker.pending), ({}, None))
+            for _ in range(10):
+                w.read()
+        self.assertEqual(w.tail.behind, 0)
+        self.assertEqual(w.tracker.pending["src"], "sidechain")
+
+
+# =====================================================================================
+# the main thread's own work in flight
+# =====================================================================================
+
+def block(ts, ref, content, stop, mid="msg_01Main"):
+    """One block of a main-thread reply as claude 2.1.304 writes it: a record per content
+    block, each naming its request; "stop_reason": null while the reply still streams."""
+    rec = main_reply(ts, ref)
+    rec["message"].update(id=mid, content=[content], stop_reason=stop)
+    return rec
+
+
+def tool_use(tid="toolu_1", command="./migrate.sh"):
+    return {"type": "tool_use", "id": tid, "name": "Bash", "input": {"command": command}}
+
+
+def result_of(ts, tid="toolu_1"):
+    return cc_user(ts, [{"type": "tool_result", "tool_use_id": tid, "content": "ok"}],
+                   toolUseResult={"stdout": "ok"})
+
+
+THINKING = {"type": "thinking", "thinking": "", "signature": "c2ln"}
+TEXT = {"type": "text", "text": "Done."}
+
+
+class MainThreadBusyTests(unittest.TestCase):
+    T = 1792440000
+
+    def busy(self, records):
+        return ar.main_thread_busy(main_lines(records))
+
+    def test_what_the_main_thread_is_in_the_middle_of(self):
+        t, sent = self.T, api_request(self.T, "req_m1")
+        cases = {
+            "request": [cc_user(t - 1, "migrate the db"), sent],
+            "stream": [sent, block(t + 20, "req_m1", THINKING, None)],
+            "tool": [sent, block(t + 20, "req_m1", THINKING, "tool_use"),
+                     block(t + 21, "req_m1", tool_use(), "tool_use")],
+        }
+        for want, records in cases.items():
+            self.assertEqual(self.busy(records), want, want)
+        # a reply whose tool_use block is still to come (its thinking says tool_use already)
+        self.assertEqual(self.busy([sent, block(t + 20, "req_m1", THINKING, "tool_use")]),
+                         "stream")
+        # two tools at once: one result is not both
+        two = [sent, block(t + 20, "req_m1", tool_use("toolu_1"), "tool_use"),
+               block(t + 20, "req_m1", tool_use("toolu_2", "make test"), "tool_use"),
+               result_of(t + 30, "toolu_1")]
+        self.assertEqual(self.busy(two), "tool")
+        self.assertIsNone(self.busy(two + [result_of(t + 90, "toolu_2")]))
+
+    def test_by_request_whatever_the_order_of_the_file(self):
+        t = self.T
+        # 2.1.304 writes a request as it sends it: before the prompt that led to it...
+        self.assertEqual(self.busy([api_request(t, "req_m1"), cc_user(t, "migrate the db")]),
+                         "request")
+        # ...and before the previous reply's last blocks and tool results
+        self.assertEqual(self.busy([api_request(t, "req_m1"), api_request(t + 5, "req_m2"),
+                                    block(t + 4, "req_m1", tool_use(), "tool_use"),
+                                    result_of(t + 5)]), "request")
+        self.assertIsNone(self.busy([api_request(t, "req_m1"), api_request(t + 5, "req_m2"),
+                                     block(t + 4, "req_m1", tool_use(), "tool_use"),
+                                     result_of(t + 5),
+                                     block(t + 9, "req_m2", TEXT, "end_turn")]))
+
+    def test_idle_or_untold(self):
+        t, sent = self.T, api_request(self.T, "req_m1")
+        compact_boundary = {"type": "system", "subtype": "compact_boundary", "timestamp": iso(t + 60)}
+        for name, records in {
+            "a finished reply": [sent, block(t + 5, "req_m1", TEXT, "end_turn")],
+            "its tools all answered": [sent, block(t + 5, "req_m1", tool_use(), "tool_use"),
+                                       result_of(t + 9)],
+            "an API error": [sent, cc_api_error(t + 1, "overloaded")],
+            "interrupted mid-stream": [sent, block(t + 5, "req_m1", THINKING, None),
+                                       cc_user(t + 6, "[Request interrupted by user]")],
+            "interrupted before a word": [sent, cc_user(t + 1, "migrate the db"),
+                                          cc_user(t + 2, "[Request interrupted by user]")],
+            "a tool interrupted": [sent, block(t + 5, "req_m1", tool_use(), "tool_use"),
+                                   cc_user(t + 6, [{"type": "text", "text":
+                                                    "[Request interrupted by user for tool use]"}])],
+            "a command after the reply": [sent, block(t + 5, "req_m1", TEXT, "end_turn")]
+                                         + cc_slash(t + 6),
+            "a reply without the key": [sent, main_reply(t + 5, "req_m1", "Started it.")],
+            "a compaction after the turn": [sent, block(t + 5, "req_m1", TEXT, "end_turn"),
+                                            compact_boundary,
+                                            cc_user(t + 60, "summary", isCompactSummary=True)],
+            "notices of paused workflows": [sent, block(t + 5, "req_m1", TEXT, "end_turn"),
+                                            queue_op(t + 9), request_blob(),
+                                            cc_user(t + 10, "<task-notification>paused"
+                                                    "</task-notification>")],
+            "an agent's request": [sent, block(t + 5, "req_m1", TEXT, "end_turn"),
+                                   side(api_request(t + 6, "req_a1", AGENT))],
+            "no request on record (an older client)": [cc_user(t, "go"), cc_reply(t + 1),
+                                                       synthetic(t + 2)],
+            "nothing": [],
+        }.items():
+            self.assertIsNone(self.busy(records), name)
+
+
+class MainThreadInFlightWatcherTests(SidechainCase):
+    """An agent's verdict waits for the main thread's own request, stream or tool: the
+    account accepted it before the limit, and stopping the client would cut it off (the
+    tool's processes die with it). Fake runner and clock only."""
+
+    def run_until_probe(self, main, later, env=None, waits=None):
+        """The first probe's time after t0; ``waits``: the main-thread work the one `hold`
+        line names (reason=main-<waits>), or None when nothing waited."""
+        reset = int(self.t0) + 9000
+        w, r = self.start([], main=[cc_user(self.launched + 1, "migrate the db")] + main,
+                          env=env)
+        self.agent_file([side_reply(self.launched + 3), side_quota(self.t0 - 1, reset)])
+        for when, records in later:
+            r.at(when, lambda records=records: self.transcript(records))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual(r.signals[0], (self.PID, signal.SIGTERM))
+        if waits is None:
+            self.assertEqual(self.events(), ["watch", "detect", "switch"])
+        else:
+            self.assertEqual(self.events(), ["watch", "detect", "hold", "switch"])
+            self.assertIn(" class=quota sid=%s acct=acct-01 reason=main-%s" % (SID, waits),
+                          self.log_lines()[2])
+        return r.probes[0]["t"] - self.t0, r
+
+    def test_a_tool_the_main_thread_runs_finishes_first(self):
+        t, _ = self.run_until_probe(
+            [api_request(self.t0 - 60, "req_m1"),
+             block(self.t0 - 55, "req_m1", tool_use(), "tool_use")],
+            [(self.t0 + 240, [result_of(self.t0 + 240)])], waits="tool")
+        self.assertGreaterEqual(t, 240)
+        self.assertLess(t, 245)
+
+    def test_a_stream_the_account_accepted_finishes_first(self):
+        t, _ = self.run_until_probe(
+            [api_request(self.t0 - 40, "req_m1")],
+            [(self.t0 + 100, [block(self.t0 + 100, "req_m1", THINKING, None)]),
+             (self.t0 + 300, [block(self.t0 + 300, "req_m1", TEXT, "end_turn")])],
+            waits="request")
+        self.assertGreaterEqual(t, 300)
+        self.assertLess(t, 305)
+
+    def test_the_main_threads_own_rejection_then_stands(self):
+        # its tool ends, its next request meets the limit: that verdict moves the session
+        t, r = self.run_until_probe(
+            [api_request(self.t0 - 60, "req_m1"),
+             block(self.t0 - 55, "req_m1", tool_use(), "tool_use")],
+            [(self.t0 + 30, [result_of(self.t0 + 30), api_request(self.t0 + 30, "req_m2"),
+                             cc_quota(self.t0 + 31, resets=int(self.t0) + 9000)])],
+            waits="tool")
+        self.assertGreaterEqual(t, 30)
+        self.assertLess(t, 40)
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["reset"]), ("quota", str(int(self.t0) + 9000)))
+
+    def test_the_wait_is_capped(self):
+        # a tool that never ends (or a prompt for permission nobody answers) waits SUBAGENT_CAP
+        t, _ = self.run_until_probe(
+            [api_request(self.t0 - 60, "req_m1"),
+             block(self.t0 - 55, "req_m1", tool_use(), "tool_use")], [],
+            env={"CLAUDE_MULTIACC_AR_SUBAGENT_CAP": "120"}, waits="tool")
+        self.assertGreaterEqual(t, 120)
+        self.assertLess(t, 125)
+
+    def test_an_idle_main_thread_moves_at_grace_as_before(self):
+        t, _ = self.run_until_probe(
+            [api_request(self.t0 - 60, "req_m1"),
+             block(self.t0 - 55, "req_m1", tool_use(), "tool_use"), result_of(self.t0 - 50),
+             api_request(self.t0 - 50, "req_m2"),
+             block(self.t0 - 45, "req_m2", TEXT, "end_turn"), queue_op(self.t0 - 2)], [])
+        self.assertGreaterEqual(t, 5)
+        self.assertLess(t, 10)
+
+
+if __name__ == "__main__":
+    unittest.main()