claude-multiacc 2.0.58 → 2.0.60

package/tests/test_autoresume_memory.py

@@ -0,0 +1,1141 @@
+#!/usr/bin/env python3
+"""A claude client at critical memory is stopped and resumed like one at a usage limit.
+
+claude 2.1.304 reads its heap every 10 s and, from 2.5 GiB on, shows "Critical memory usage
+(8.3GB) — restart and resume with claude --continue" in its prompt footer; nothing of it
+reaches the transcript. On 2026-10-20 a session running eight background workflows reached
+8.3GB, and its client then ignored SIGTERM for more than 15 s. The watcher reads its own pane
+for the banner (capture-pane, read-only) and moves the session through the usual path.
+Disposable pools, the fake runner and its fake clock only: no real signal, process or tmux."""
+
+import json
+import os
+import signal
+import sys
+import time
+import unittest
+from unittest import mock
+
+import test_autoresume as fixtures
+from test_autoresume import (CX_SID, SID, ar, cc_api_error, cc_quota, cc_reply, cc_user, cfg,
+                             cx_meta, jl)
+from test_autoresume_sidechain import TEXT, api_request, block, result_of, tool_use, write
+
+SOCK = "/private/tmp/tmux-501/default"
+RULE = "─" * 200
+BANNER = ("Critical memory usage (8.3GB) — restart and resume with claude --continue, "
+          "or run /compact")
+MODE = "  ⏵⏵ bypass permissions on · 3 shells"
+CONVERSATION = ["⏺ Started the release workflows; I will report when they finish.", ""]
+WAITING = "✻ Waiting for 3 dynamic workflows to finish"
+COMPACTING = "✻ Compacting conversation… (1m 12s · esc to interrupt · ctrl+t to show todos)"
+
+
+def screen(banner=BANNER, above=CONVERSATION, footer=MODE, tasks=3, width=200, spinner=WAITING,
+           prompt=("❯\xa0",), task_names=None):
+    """A claude 2.1.304 pane as `capture-pane -p -J` prints it: the conversation, the spinner,
+    the prompt between its two rules (its row the mode indicator and a no-break space), the
+    footer row (the notification column right-aligned after the mode line), a row per
+    background task, then blank rows down to the bottom."""
+    rows = list(above) + [spinner, "", RULE[:width - 12] + " ultracode ─"] + list(prompt) \
+        + [RULE[:width]]
+    if banner:
+        rows.append(footer + " " * max(2, width - len(footer) - len(banner) - 2) + banner)
+    else:
+        rows.append(footer)
+    rows.append("")
+    names = task_names or ["release-step-%d" % i for i in range(tasks)]
+    rows += ["  ◯ %s          ▰▱▱▱▱▱▱▱▱▱▱▱  1/12 · 10m42s · ↓ 1.4m tokens" % name
+             for name in names]
+    return "\n".join(rows + [""] * 8) + "\n"
+
+
+QUOTED = ["⏺ The pane said: " + BANNER,
+          "  ⎿  2026-10-20T08:01:44Z Critical memory usage (8.3GB) — restart and resume with "
+          "claude --continue",
+          "Critical memory usage (9GB) — restart and resume with claude --continue", ""]
+QUOTE = "Critical memory usage (8.3GB) — restart and resume with claude --continue"
+
+
+def permission_dialog(quoted, width=120, title="Bash command"):
+    """claude 2.1.304's permission dialog, drawn in the prompt's place (its frame, Da, draws a
+    top border alone: one rule across the pane) with what the tool would run quoted in its
+    body; neither the prompt's box nor its footer is drawn while it is up."""
+    return "\n".join(CONVERSATION + [
+        "⏺ Bash(" + quoted[:60] + ")", "", "─" * width, " " + title, "", "   " + quoted,
+        "   Print the banner the watcher must know", "", " Do you want to proceed?",
+        " ❯ 1. Yes", "   2. Yes, and don't ask again for echo commands in /work",
+        "   3. No, and tell Claude what to do differently (esc)"] + [""] * 6) + "\n"
+
+
+def plan_dialog(plan, width=120):
+    """The plan's approval (2.1.304): "Ready to code?" in the same top-border frame, the plan,
+    then its options in a second such frame -- two rules, the plan and the options under them."""
+    return "\n".join(CONVERSATION + [
+        "", "─" * width, " Ready to code?", "", " Here is Claude's plan:", ""] + list(plan) + [
+        "", "─" * width,
+        " Claude has written up a plan and is ready to execute. Would you like to proceed?", "",
+        " ❯ 1. Yes, and use auto mode", "   2. Yes, manually approve edits",
+        "   3. No, keep planning", "", " ctrl+g to edit in vim · ~/.claude/plans/memory.md"]
+        + [""] * 4) + "\n"
+
+
+class MemoryBannerTests(unittest.TestCase):
+    """memory_banner: the client's own words, where the client shows them, and nowhere else."""
+
+    def test_the_banner_in_the_footer_names_the_size(self):
+        self.assertEqual(ar.memory_banner(screen()), "8.3GB")
+        # without ", or run /compact" (a client that cannot compact here), and in colour
+        short = BANNER.split(",")[0]
+        self.assertEqual(ar.memory_banner(screen(short)), "8.3GB")
+        red = "\x1b[38;2;255;107;128m" + short + "\x1b[39m"
+        self.assertEqual(ar.memory_banner(screen(red).replace("❯\xa0", "\x1b[39m❯\xa0")),
+                         "8.3GB")
+        for size in ("2.5GB", "12GB", "10.1GB", "900MB"):
+            self.assertEqual(ar.memory_banner(screen(BANNER.replace("8.3GB", size))), size)
+
+    def test_a_narrow_pane_truncates_it_and_a_column_footer_stacks_it(self):
+        for cut, want in (("Critical memory usage (8.3GB) — restart and r…", "8.3GB"),
+                          ("Critical memory usage (8.3GB) …", "8.3GB"),
+                          ("Critical memory usage (8.3GB)…", "8.3GB"),
+                          ("Critical memory usage (8.3G…", None),
+                          ("Critical memory usa…", None)):
+            self.assertEqual(ar.memory_banner(screen(cut, width=80)), want, cut)
+        stacked = screen(None, footer=MODE + "\n" + " " * 30 + BANNER[:60] + "…")
+        self.assertEqual(ar.memory_banner(stacked), "8.3GB")
+        # a row too narrow for both: the notification column abuts the mode line, cut short
+        for left in ("  ⏵⏵ bypass permissions on · 3 she…", "  ⏵⏵ bypass permissions on"):
+            abutting = screen(None, footer=left + BANNER[:70] + "…", width=110)
+            self.assertEqual(ar.memory_banner(abutting), "8.3GB", left)
+        # the footer's every row counts, down to its first blank one: the column wrapped under
+        # the mode line, or under other notifications, as a real 2.1.304 footer lays them out
+        # at 70 and 80 columns
+        wrapped = screen(None, width=70, footer="  ⏵⏵ auto mode on (shift+tab to cycle)\n"
+                         + " " * 4 + BANNER[:63] + "…")
+        self.assertEqual(ar.memory_banner(wrapped), "8.3GB")
+        crowded = screen(None, width=80, footer="\n".join([
+            "  ⏵⏵ auto mode on (shift+tab to cycle)", " " * 52 + "Not logged in · Run /login",
+            "  tmux focus-events off · add 'set -g focus-events on' to ~/.tmux.conf and re…",
+            " " * 4 + BANNER[:73] + "…"]))
+        self.assertEqual(ar.memory_banner(crowded), "8.3GB")
+        # a fullscreen client ("tui": "fullscreen"; the pool's accounts run "default") draws its
+        # notifications over the row above the box instead, among the conversation's rows,
+        # where the banner's words cannot be told from a reply's: that row is never read
+        overlaid = screen(None).replace("\n\n" + RULE[:188], "\n" + " " * 110 + BANNER[:86]
+                                        + "\n" + RULE[:188], 1)
+        self.assertIn(BANNER[:86], overlaid)
+        self.assertIsNone(ar.memory_banner(overlaid))
+
+    def test_the_words_in_the_conversation_never_count(self):
+        # a reply quoting it, a tool's log line, a pasted line: all above the prompt's box
+        self.assertIsNone(ar.memory_banner(screen(None, above=QUOTED)))
+        # ...however many rows the footer and the tasks below it take
+        self.assertIsNone(ar.memory_banner(screen(None, above=QUOTED, tasks=0)))
+        self.assertIsNone(ar.memory_banner(screen(None, above=QUOTED, tasks=20)))
+        # and with the real banner in the footer it is the footer's size that counts
+        self.assertEqual(ar.memory_banner(screen(BANNER.replace("8.3GB", "3GB"),
+                                                 above=QUOTED)), "3GB")
+
+    def test_without_the_prompts_box_there_is_no_banner(self):
+        # a screen with no rule at all (the transcript view, a full-screen picker)
+        self.assertIsNone(ar.memory_banner("\n".join(QUOTED + ["", "  esc to go back"])))
+        # a dialog in the prompt's place: its words are inside its box, above the border
+        dialog = ["╭" + "─" * 98 + "╮", "│ " + BANNER + " │", "│ Do you want to proceed? │",
+                  "╰" + "─" * 98 + "╯", "  Esc to cancel"]
+        self.assertIsNone(ar.memory_banner("\n".join(CONVERSATION + dialog) + "\n\n"))
+        # what is below the footer's first blank row is not the footer
+        self.assertIsNone(ar.memory_banner(screen(None, tasks=0) + "\n".join(
+            [BANNER] + ["  ◯ task-%d" % i for i in range(40)])))
+        self.assertIsNone(ar.memory_banner(""))
+        self.assertIsNone(ar.memory_banner(None))
+
+    def test_a_dialog_in_the_boxs_place_quotes_nothing(self):
+        # 2.1.304 frames its permission and plan dialogs with a top border alone, one rule
+        # across the pane, and what the tool would run (a command, an Edit's diff, the plan) is
+        # under it. That rule opens no prompt box, and the banner's words there never count
+        for quoted in ("echo '%s'" % QUOTE, "+    " + BANNER, QUOTE,
+                       "grep -n 'Critical memory usage (8.3GB) — restart' docs/AUTORESUME.md"):
+            self.assertIsNone(ar.memory_banner(permission_dialog(quoted)), quoted)
+            self.assertIsNone(ar.memory_banner(permission_dialog(quoted, title=quoted)), quoted)
+        self.assertIsNone(ar.memory_banner(plan_dialog(
+            ["1. Watch the pane for", "   " + QUOTE, "2. Restart and resume the session"])))
+        self.assertIsNone(ar.memory_banner(plan_dialog([QUOTE, BANNER])))
+        # a picker (the session list) quoting an earlier prompt that pasted it, and a question
+        picker = ["", " Resume Session", "", " ❯ " + QUOTE + "…  2m ago",
+                  "   fix the release workflows   1h ago", "",
+                  " ↑/↓ to select · Enter to resume · Esc to cancel"]
+        self.assertIsNone(ar.memory_banner("\n".join(CONVERSATION + picker) + "\n"))
+        question = ["", "─" * 120, " ☐ Restart", "", "The pane shows: " + QUOTE, "",
+                    " ❯ 1. Restart now", "   2. Run /compact first", "   3. Type something."]
+        self.assertIsNone(ar.memory_banner("\n".join(CONVERSATION + question) + "\n"))
+
+    def test_only_the_prompts_own_row_opens_the_box(self):
+        # the prompt's row is the client's: its mode indicator in the pane's first column, then
+        # a no-break space. A copy of the box -- a capture pasted into the external editor, a
+        # picker's row under a rule -- has a plain space there
+        for prompt in ("❯\xa0", "❯\xa0what now?"):
+            pasted = screen(prompt=[prompt]).replace("❯\xa0", "❯ ")
+            self.assertIsNone(ar.memory_banner(pasted), prompt)
+            vim = pasted.rstrip("\n") + "\n" + "\n".join(
+                ["~"] * 6 + ['"/tmp/claude-prompt-7f3a.md" 14L, 1320B'])
+            self.assertIsNone(ar.memory_banner(vim), prompt)
+        picker = ["─" * 120, "❯ fix the release workflows", "─" * 120, "  " + QUOTE]
+        self.assertIsNone(ar.memory_banner("\n".join(CONVERSATION + picker) + "\n"))
+        # ...right under a rule from the pane's first column: an indented rule (a reply's
+        # markdown) opens nothing, and neither does a prompt row with no rule above it
+        self.assertIsNone(ar.memory_banner(screen().replace(RULE[:188] + " ultracode ─",
+                                                            "  " + RULE[:186])))
+        self.assertIsNone(ar.memory_banner(screen().replace(RULE[:188] + " ultracode ─\n", "")))
+        # ...and closed by one: no rule under it, no box
+        self.assertIsNone(ar.memory_banner(screen().replace("\xa0\n" + RULE[:200] + "\n",
+                                                            "\xa0\n")))
+
+    def test_every_mode_indicator_and_a_draft_of_several_rows(self):
+        for prompt in (["!\xa0"], ["@reviewer\xa0"], [">\xa0ls -la"],
+                       ["❯\xa0first line", "  second line"],
+                       ["❯\xa0" + "x" * 150] + ["  " + "y" * 150] * 20):
+            self.assertEqual(ar.memory_banner(screen(prompt=prompt)), "8.3GB", prompt[0])
+        # the draft is inside the box: the banner's words typed or pasted there never count,
+        # not even a pasted capture with a rule and a footer of its own (the box indents them)
+        draft = ["❯\xa0what does this mean?", "  " + RULE[:60], "  " + MODE + "    " + BANNER]
+        self.assertIsNone(ar.memory_banner(screen(None, prompt=draft)))
+        # a box holding a draft taller than PROMPT_ROWS is not read
+        tall = ["❯\xa0x"] + ["  more"] * ar.PROMPT_ROWS
+        self.assertIsNone(ar.memory_banner(screen(prompt=tall)))
+
+    def test_the_background_tasks_below_the_footer_never_count(self):
+        # the task list starts after the footer's first blank row: a workflow named with the
+        # banner's words, whole or cut at its ellipsis, is not the client's status
+        for name in (QUOTE, QUOTE[:40] + "…", "Critical memory usage (8.3GB) - repro"):
+            self.assertIsNone(ar.memory_banner(screen(None, task_names=[name, "release"])), name)
+            self.assertEqual(ar.memory_banner(screen(task_names=[name])), "8.3GB", name)
+
+    def test_only_the_banners_own_shape(self):
+        task = "  ◯ Critical memory usage (8.3GB) leak hunt  ▱▱▱▱▱▱▱▱  0/1 · 2m"
+        for row in (task, "  Critical memory usage (8.3GB) restart and resume",
+                    "  Critical memory usage (lots) — restart",
+                    "  critical memory usage (8.3GB) —",
+                    "  Critical memory usage 8.3GB — restart",
+                    "  Critical memory usage (8.3 GB) —",
+                    # the client's dash and words, whole or cut at an ellipsis, and nothing else
+                    "  Critical memory usage (8.3GB) - restart and resume with claude --continue",
+                    "  Critical memory usage (8.3GB) – restart and resume with claude --continue",
+                    "  Critical memory usage (8.3GB)",
+                    "  Critical memory usage (8.3GB) — restart and resume later",
+                    "  Critical memory usage (8.3GB) — restart and resume later…",
+                    "  Critical memory usage (8.3GB) - repro…"):
+            self.assertIsNone(ar.memory_banner(screen(None, footer=MODE + "\n" + row)), row)
+        # without ", or run /compact" (a client that cannot compact there) it is the banner
+        self.assertEqual(ar.memory_banner(screen(None, footer=MODE + "   " + QUOTE)), "8.3GB")
+
+    def test_after_the_size_only_the_banners_own_dash_or_its_cut(self):
+        # 2.1.304 draws an em dash after the size, or cuts its text at an ellipsis (Ink's
+        # truncation, anywhere from right after the size on): a hyphen or an en dash there,
+        # whole or cut, is never the client's
+        for dash in ("-", "–"):
+            for row in (QUOTE.replace("—", dash), BANNER.replace("—", dash),
+                        BANNER.replace("—", dash)[:50] + "…",
+                        "Critical memory usage (8.3GB) %s…" % dash):
+                self.assertIsNone(ar.memory_banner(screen(row)), row)
+        for row in (QUOTE, BANNER[:50] + "…", "Critical memory usage (8.3GB) —…",
+                    "Critical memory usage (8.3GB) …", "Critical memory usage (8.3GB)…"):
+            self.assertEqual(ar.memory_banner(screen(row)), "8.3GB", row)
+
+    def test_it_ends_its_row_but_for_the_clients_own_pills(self):
+        # The banner is the notification column's last line: whole or cut, nothing follows it
+        # on its row but the pills 2.1.304 draws right of that column, a stashed prompt's and
+        # an active goal's. A task's row, a log line or a reply that quotes it goes on
+        for row in (QUOTE + " (see the docs)", BANNER + " now", QUOTE + ", or run /compact please",
+                    "Critical memory usage (8.3GB)… leak hunt",
+                    BANNER[:50] + "…  ▰▱▱▱▱▱▱▱  1/12 · 10m42s",
+                    QUOTE + "  10m42s · ↓ 1.4k tokens"):
+            self.assertIsNone(ar.memory_banner(screen(row)), row)
+        for pills in (" · › stashed", " › stashed", "◎ /goal active", " · ◎ /goal active (5m)",
+                      " › stashed · ◎ /goal active (1h)"):
+            for row in (BANNER, QUOTE, BANNER[:50] + "…", "Critical memory usage (8.3GB)…"):
+                self.assertEqual(ar.memory_banner(screen(row + pills)), "8.3GB", row + pills)
+            self.assertIsNone(ar.memory_banner(screen(BANNER + pills + " later")), pills)
+
+    def test_a_tasks_row_never_counts_even_right_under_the_footer(self):
+        # A task's name and description are the model's words. Its row -- the pointer or two
+        # spaces, an agent's tree connector, the task's bullet -- is never read, even with no
+        # blank row between the footer and the task list
+        for row in ("  ⏸ Critical memory usage (3GB)…",  # a paused workflow, its name cut
+                    "  ◯ " + QUOTE, "❯ ◯ " + BANNER, "> ◯ " + QUOTE,  # one selected
+                    "  ⏺ " + QUOTE, "  ● " + QUOTE[:40] + "…",  # the one viewed
+                    "  └ ◯ " + QUOTE, "    ├ ◯ " + QUOTE,  # an agent's agents
+                    "  ( ) " + QUOTE):  # a terminal without the unicode bullets
+            self.assertIsNone(ar.memory_banner(screen(None, footer=MODE + "\n" + row)), row)
+            self.assertIsNone(ar.memory_banner(screen(None, footer=MODE + "\n" + MODE + "\n"
+                                                      + row)), row)
+            # ...while the client's own banner in the footer above it counts
+            self.assertEqual(ar.memory_banner(screen(None, footer=MODE + "    " + BANNER
+                                                     + "\n" + row)), "8.3GB", row)
+        # The footer's first row is the client's own, never a task's (the list comes after the
+        # footer): a status line drawn with a bullet first still has the banner beside it
+        for status in ("  ● main · ~/release", "  ◯ idle · opus"):
+            self.assertEqual(ar.memory_banner(screen(None, footer=status + "    " + BANNER
+                                                     + "\n" + MODE)), "8.3GB", status)
+
+    def test_a_compaction_under_way_shows_in_the_spinner_above_the_box(self):
+        self.assertTrue(ar.compacting(screen(spinner=COMPACTING)))
+        self.assertTrue(ar.compacting(screen(None, spinner=COMPACTING)))
+        # the todo list between the spinner and the box
+        todos = [COMPACTING, "  ⎿  ☐ Build the release", "     ☐ Write the notes",
+                 "     ☒ Tag it"]
+        self.assertTrue(ar.compacting(screen(above=CONVERSATION + todos[:-1],
+                                             spinner=todos[-1])))
+        self.assertFalse(ar.compacting(screen()))
+        self.assertFalse(ar.compacting(screen(spinner="✻ Compacted. ctrl+o to see the summary")))
+        # below the box it is a task's name, not the client's spinner; and no box, no spinner
+        self.assertFalse(ar.compacting(screen(footer=MODE + "\n  ◯ " + COMPACTING[2:])))
+        self.assertFalse(ar.compacting("\n".join([COMPACTING, "", RULE, "  esc to cancel"])))
+        self.assertFalse(ar.compacting(""))
+
+    def test_sizes_the_way_the_client_prints_them(self):
+        gib, mib = 1 << 30, 1 << 20
+        for nbytes, want in ((int(8.3 * gib), "8.3GB"), (10 * gib, "10GB"),
+                             (int(2.5 * gib), "2.5GB"), (512 * mib, "512MB"), (3 * 1024, "3KB")):
+            self.assertEqual(ar.format_size(nbytes), want)
+
+    def test_capture_is_a_read(self):
+        self.assertEqual(ar.capture_argv(SOCK, "%7"),
+                         ["tmux", "-S", SOCK, "capture-pane", "-p", "-J", "-t", "%7"])
+
+
+class MemoryRulesTests(unittest.TestCase):
+    T = 1792440000
+
+    def test_knobs(self):
+        c = ar.Config("claude", {})
+        self.assertEqual((c.memory_scan, c.memory_min_uptime, c.memory_busy_cap,
+                          c.memory_per_hour, c.memory_backoff, c.memory_limit_mb),
+                         (30.0, 900.0, 600.0, 2, 600.0, 0))
+        c = cfg(MEMORY_SCAN=0, MEMORY_MIN_UPTIME=60, MEMORY_BUSY_CAP=30, MEMORY_PER_HOUR=5,
+                MEMORY_BACKOFF=90, MEMORY_LIMIT_MB=12000)
+        self.assertEqual((c.memory_scan, c.memory_min_uptime, c.memory_busy_cap,
+                          c.memory_per_hour, c.memory_backoff, c.memory_limit_mb),
+                         (0.0, 60.0, 30.0, 5, 90.0, 12000))
+        self.assertEqual(cfg(MEMORY_PER_HOUR="lots").memory_per_hour, 2)
+
+    def test_per_hour_budget(self):
+        c, t = ar.Config("claude", {}), self.T
+        self.assertEqual(ar.budget_check("memory", 0, "", t, c), (True, ""))
+        one = "memory:%d" % (t - 3000)
+        self.assertEqual(ar.budget_check("memory", 0, one, t, c), (True, ""))
+        two = "%s,quota:%d,memory:%d" % (one, t - 2000, t - 100)
+        self.assertEqual(ar.budget_check("memory", 0, two, t, c), (False, "memory-budget"))
+        # an hour on, the oldest no longer counts; other classes never count against it
+        self.assertEqual(ar.budget_check("memory", 0, two, t + 700, c), (True, ""))
+        self.assertEqual(ar.budget_check("memory", 0, "crash:%d,transient:%d" % (t, t), t, c),
+                         (True, ""))
+        self.assertEqual(ar.budget_check("memory", 20, "", t, c), (False, "depth"))
+        # ...and memory relaunches never spend the others' budgets
+        self.assertEqual(ar.budget_check("crash", 0, two, t, c), (True, ""))
+
+    def test_the_prompt_says_why_and_never_claims_another_account(self):
+        text = ar.resume_prompt("memory", detail="8.3GB")
+        self.assertTrue(text.startswith(ar.PROMPT_PREFIX + " This session was restarted "
+                                        "automatically because the previous process reached "
+                                        "critical memory usage (8.3GB). Continue the task"))
+        self.assertIn("critical memory usage.", ar.resume_prompt("memory"))
+        self.assertEqual(ar.resume_prompt("memory", "Go on: {reason}, please", "9GB"),
+                         "Go on: the previous process reached critical memory usage (9GB), please")
+        self.assertEqual(ar.relaunch_argv("claude", ["--dangerously-skip-permissions"], SID,
+                                          "memory", detail="8.3GB"),
+                         ["--dangerously-skip-permissions", "--resume", SID, text])
+        # a relaunch the probe accepts on any account with room, the one it leaves included
+        self.assertTrue(ar.probe_allows("memory", "acct-01", "soft", "acct-01"))
+        self.assertFalse(ar.probe_allows("memory", "acct-01", "hard", "acct-01"))
+
+
+class MemoryRunner(fixtures.FakeRunner):
+    """The fake runner with a pane to read: ``screen`` is what capture-pane prints (a hook can
+    change it), ``used`` the client's footprint in bytes (None: unreadable)."""
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.screen = screen()
+        self.used = None
+        self.footprints = 0
+
+    def run(self, argv, timeout, env=None, cwd=None):
+        if argv[0] == "tmux" and "capture-pane" in argv:
+            self.calls.append({"argv": list(argv), "env": env, "cwd": cwd, "t": self.t})
+            return 0, self.screen
+        return super().run(argv, timeout, env, cwd)
+
+    def footprint(self, pid):
+        self.footprints += 1
+        return self.used if pid in self.live else None
+
+    @property
+    def captures(self):
+        return [c for c in self.calls if c["argv"][0] == "tmux" and "capture-pane" in c["argv"]]
+
+
+class MemoryCase(fixtures.PoolCase):
+    def setUp(self):
+        super().setUp()
+        self.launched = int(self.t0) - 1000  # past MEMORY_MIN_UPTIME: the first scan is now
+
+    def transcript(self, records, sid=SID):
+        """Main transcript lines as the client writes them (compact JSON: main_thread_busy
+        knows a request record by its first bytes)."""
+        path = self.proj / (sid + ".jsonl")
+        write(path, records)
+        return path
+
+    def idle(self, at=None):
+        """A main thread whose last reply has finished (its workflows run on in the
+        background): nothing in flight."""
+        at = self.launched + 10 if at is None else at
+        return [cc_user(at, "run the release workflows"), api_request(at, "req_m1"),
+                block(at + 10, "req_m1", TEXT, "end_turn")]
+
+    def start(self, argv=None, main=None, env=None, hist="", launched=None):
+        """A fresh session -- state, registry, transcript, log -- launched at ``launched``
+        (default 1000 s ago: past MEMORY_MIN_UPTIME), the banner on its pane."""
+        if launched is not None:
+            self.launched = launched
+        for path in (self.proj / (SID + ".jsonl"), self.root / "selection.log"):
+            if path.exists():
+                path.unlink()
+        state = self.write_state(["--dangerously-skip-permissions"] if argv is None else argv,
+                                 hist=hist)
+        self.registry()
+        self.transcript(self.idle() if main is None else main)
+        return self.watcher(state, env, MemoryRunner(self.t0, self.PID, self.PPID,
+                                                      self.self_path))
+
+    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 assert_untouched(self, runner):
+        self.assertEqual((runner.probes, runner.signals, runner.sends, self.relaunch_files()),
+                         ([], [], [], []))
+
+    def assert_relaunched(self, runner, size="8.3GB"):
+        kv, argv = self.relaunch_of(runner)
+        self.assertEqual(argv, ["--dangerously-skip-permissions", "--resume", SID,
+                                ar.resume_prompt("memory", detail=size)])
+        self.assertEqual({k: kv[k] for k in ("class", "acct", "reset", "rtype", "sid", "depth",
+                                             "avoid")},
+                         {"class": "memory", "acct": "acct-01", "reset": "", "rtype": "",
+                          "sid": SID, "depth": "1", "avoid": ""})
+        return kv
+
+
+class MemoryWatcherTests(MemoryCase):
+    def test_the_banner_moves_the_session_like_a_limit_and_marks_nothing(self):
+        w, r = self.start()
+        self.assertEqual(w.run(), 0)
+        prompt = ar.resume_prompt("memory", detail="8.3GB")
+        self.assertEqual(len(r.probes), 1)
+        probe = r.probes[0]
+        self.assertGreaterEqual(probe["t"] - self.t0, 5.0)  # GRACE after the first scan
+        self.assertLess(probe["t"] - self.t0, 7.0)
+        self.assertEqual(probe["argv"], [self.self_path, "--dangerously-skip-permissions",
+                                         "--resume", SID, prompt])
+        # the account it leaves is not avoided: it may take the session back
+        self.assertEqual(probe["env"]["CLAUDE_MULTIACC_AR_AVOID"], "")
+        self.assertEqual(r.signals, [(self.PID, signal.SIGTERM)])
+        self.assert_sequence(r)
+        kv = self.assert_relaunched(r)
+        self.assertRegex(kv["hist"], r"^memory:\d+$")
+        self.assertEqual(self.events(), ["watch", "detect", "switch"])
+        self.assertIn(" class=memory code=critical_memory sid=%s acct=acct-01 reset=- size=8.3GB "
+                      "src=pane" % SID, self.log_lines()[1])
+        self.assertIn(" from=acct-01 class=memory sid=%s depth=1 probe=acct-02 size=8.3GB"
+                      % SID, self.log_lines()[2])
+        # the pane is only read until the stop (the scan, and once more right before it); the
+        # keys are the relaunch's, into the shell, after the client is gone
+        term = r.index(lambda a: a[0] == "<signal>")
+        keys = [i for i, c in enumerate(r.calls)
+                if c["argv"][0] == "tmux" and "send-keys" in c["argv"]]
+        self.assertGreater(min(keys), term)
+        self.assertEqual([c["argv"] for c in r.captures], [ar.capture_argv(SOCK, "%7")] * 2)
+        self.assertLess(max(i for i, c in enumerate(r.calls) if c in r.captures), term)
+        self.assertFalse([p for acct in ("acct-01", "acct-02") for p in (self.root / acct).iterdir()
+                          if p.name in (".limited", ".expired")])
+
+    def test_the_account_it_leaves_may_take_it_back(self):
+        w, r = self.start()
+        r.probe_out = "pick=acct-01 tier=soft\n"
+        self.assertEqual(w.run(), 0)
+        self.assert_relaunched(r)
+        self.assertIn(" class=memory sid=%s depth=1 probe=acct-01 size=8.3GB" % SID,
+                      self.log_lines()[-1])
+
+    def test_nowhere_to_go_holds_and_nothing_is_stopped(self):
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_HOLD_REPROBE": "20"})
+        r.probe_out = "pick=acct-01 tier=hard\n"
+        self.stop_at(r, self.t0 + 50)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 3)  # ~5 s, ~25 s, ~45 s
+        self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+        self.assertEqual(self.events(), ["watch", "detect", "hold"])
+        self.assertIn(" class=memory sid=%s acct=acct-01 reason=no-room pick=acct-01 tier=hard"
+                      % SID, self.log_lines()[-1])
+
+    def test_the_banners_words_in_the_conversation_move_nothing(self):
+        w, r = self.start()
+        r.screen = screen(None, above=QUOTED)
+        self.stop_at(r, self.t0 + 100)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])
+        self.assertEqual(len(r.captures), 4)  # t0, +30, +60, +90: looked, found nothing
+
+    def test_a_dialog_quoting_the_banner_moves_nothing(self):
+        # The main thread asks to run a command that quotes the banner, and nobody answers for
+        # twenty minutes: 2.1.304 draws the request in the prompt's place under one rule, and
+        # the watcher used to read it as the footer -- a verdict, then the healthy client
+        # stopped at MEMORY_BUSY_CAP. The same with the main thread idle (an agent asked) or
+        # a plan waiting for approval, which went in GRACE
+        t = self.t0
+        cmd = "echo '%s'" % QUOTE
+        w, r = self.start(main=self.idle() + [
+            api_request(t - 60, "req_m2"), block(t - 55, "req_m2", tool_use(command=cmd),
+                                                 "tool_use")])
+        r.screen = permission_dialog(cmd)
+        self.stop_at(r, t + 1200)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(self.events(), ["watch"])
+        self.assertEqual(len(r.captures), 40)
+        for name, scr in (("dialog", permission_dialog("+    " + BANNER, title="Edit file")),
+                          ("plan", plan_dialog(["1. On " + QUOTE, "2. Restart it"]))):
+            with self.subTest(name):
+                w, r = self.start()
+                r.screen = scr
+                self.stop_at(r, t + 100)
+                self.assertEqual(w.run(), 0)
+                self.assert_untouched(r)
+                self.assertEqual(self.events(), ["watch"])
+
+    def test_never_within_min_uptime_of_the_launch(self):
+        # a resumed session can come back as heavy as it left: no restart loop
+        w, r = self.start(launched=int(self.t0) - 60)
+        self.stop_at(r, self.t0 + 300)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual((r.captures, self.events()), ([], ["watch"]))
+        # ...and once the launch is that old, the banner still up is acted on
+        w, r = self.start(launched=int(self.t0) - 60,
+                          env={"CLAUDE_MULTIACC_AR_MEMORY_MIN_UPTIME": "300"})
+        self.assertEqual(w.run(), 0)
+        self.assertGreaterEqual(r.captures[0]["t"], self.t0 + 240)
+        self.assertGreaterEqual(r.probes[0]["t"], self.t0 + 245)
+        self.assert_relaunched(r)
+
+    def test_a_busy_main_thread_is_waited_for(self):
+        # its tool runs for four minutes: the session moves when it has its result
+        t = self.t0
+        w, r = self.start(main=self.idle() + [api_request(t - 60, "req_m2"),
+                                              block(t - 55, "req_m2", tool_use(), "tool_use")])
+        r.at(t + 240, lambda: self.transcript([result_of(t + 240)]))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertGreaterEqual(r.probes[0]["t"], t + 240)
+        self.assertLess(r.probes[0]["t"], t + 245)
+        self.assertEqual(self.events(), ["watch", "detect", "hold", "switch"])
+        self.assertIn(" class=memory sid=%s acct=acct-01 reason=main-tool" % SID,
+                      self.log_lines()[2])
+        self.assert_relaunched(r)
+
+    def test_a_reply_still_streaming_or_a_request_in_flight_waits_too(self):
+        t = self.t0
+        for busy, records, done in (
+                ("stream", [api_request(t - 20, "req_m2"), block(t - 15, "req_m2", TEXT, None)],
+                 [block(t + 100, "req_m2", TEXT, "end_turn")]),
+                ("request", [cc_user(t - 3, "and the docs?"), api_request(t - 3, "req_m2")],
+                 [block(t + 100, "req_m2", TEXT, "end_turn")])):
+            with self.subTest(busy=busy):
+                w, r = self.start(main=self.idle() + records)
+                r.at(t + 100, lambda done=done: self.transcript(done))
+                self.assertEqual(w.run(), 0)
+                self.assertGreaterEqual(r.probes[0]["t"], t + 100)
+                self.assertLess(r.probes[0]["t"], t + 105)
+                self.assertIn(" reason=main-%s" % busy, self.log_lines()[2])
+
+    def test_the_wait_is_capped_the_process_may_not_last(self):
+        # the tool runs on: MEMORY_BUSY_CAP after the wait began (the first decision, GRACE
+        # after the detection) the session moves anyway
+        t = self.t0
+        w, r = self.start(main=self.idle() + [api_request(t - 60, "req_m2"),
+                                              block(t - 55, "req_m2", tool_use(), "tool_use")],
+                          env={"CLAUDE_MULTIACC_AR_MEMORY_BUSY_CAP": "120"})
+        self.assertEqual(w.run(), 0)
+        self.assertGreaterEqual(r.probes[0]["t"], t + 5 + 120)
+        self.assertLess(r.probes[0]["t"], t + 5 + 123)
+        self.assertEqual(self.events(), ["watch", "detect", "hold", "switch"])
+        self.assert_relaunched(r)
+
+    def term_at(self, runner):
+        return [c["t"] - self.t0 for c in runner.calls
+                if c["argv"][:3] == ["<signal>", self.PID, signal.SIGTERM]]
+
+    def test_a_hold_for_room_spends_none_of_the_wait_for_the_main_thread(self):
+        # The wait used to be counted from the detection: eleven minutes without room, then a
+        # tool the user started was cut off the moment an account freed up. It is counted from
+        # when the main thread was found busy, so the tool is waited for
+        t = self.t0
+        w, r = self.start()
+        r.probe_out = "pick=acct-01 tier=hard\n"  # no room: held, probed again every minute
+        tpath = self.proj / (SID + ".jsonl")
+        r.at(t + 650, lambda: write(tpath, [cc_user(t + 650, "run the migration"),
+                                            api_request(t + 650, "req_m3"),
+                                            block(t + 652, "req_m3", tool_use(), "tool_use")]))
+        r.at(t + 660, lambda: setattr(r, "probe_out", "pick=acct-02 tier=eligible\n"))
+        r.at(t + 900, lambda: write(tpath, [result_of(t + 900)]))
+        self.assertEqual(w.run(), 0)
+        term = self.term_at(r)
+        self.assertEqual(len(term), 1)
+        self.assertGreaterEqual(term[0], 900)
+        self.assertLess(term[0], 905)
+        holds = [line for line in self.log_lines() if " hold " in line]
+        self.assertIn(" reason=no-room ", holds[0])
+        self.assertIn(" class=memory sid=%s acct=acct-01 reason=main-tool" % SID, holds[-1])
+        self.assert_relaunched(r)
+        # ...for MEMORY_BUSY_CAP at most, counted from then: a tool that runs on is cut off
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_BUSY_CAP": "200"})
+        r.probe_out = "pick=acct-01 tier=hard\n"
+        r.at(t + 650, lambda: write(tpath, [cc_user(t + 650, "run the migration"),
+                                            api_request(t + 650, "req_m3"),
+                                            block(t + 652, "req_m3", tool_use(), "tool_use")]))
+        r.at(t + 660, lambda: setattr(r, "probe_out", "pick=acct-02 tier=eligible\n"))
+        self.assertEqual(w.run(), 0)
+        term = self.term_at(r)
+        self.assertGreaterEqual(term[0], 850)
+        self.assertLess(term[0], 855)
+
+    def test_each_busy_stretch_has_its_own_cap(self):
+        # held for want of room through a first tool (+100..+300), the main thread idle, then a
+        # second tool from +500; room at +520: the second one is waited for, from +500
+        t = self.t0
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_BUSY_CAP": "300"})
+        r.probe_out = "pick=acct-01 tier=hard\n"
+        tpath = self.proj / (SID + ".jsonl")
+        for begin, end, rid, tid in ((100, 300, "req_m3", "toolu_3"),
+                                     (500, 700, "req_m4", "toolu_4")):
+            r.at(t + begin, lambda begin=begin, rid=rid, tid=tid: write(tpath, [
+                cc_user(t + begin, "and now"), api_request(t + begin, rid),
+                block(t + begin + 2, rid, tool_use(tid), "tool_use", mid="msg_" + rid)]))
+            r.at(t + end, lambda end=end, tid=tid: write(tpath, [result_of(t + end, tid)]))
+        r.at(t + 520, lambda: setattr(r, "probe_out", "pick=acct-02 tier=eligible\n"))
+        self.assertEqual(w.run(), 0)
+        term = self.term_at(r)
+        self.assertGreaterEqual(term[0], 700)
+        self.assertLess(term[0], 705)
+        self.assert_relaunched(r)
+
+    def test_a_transcript_verdict_in_between_starts_the_wait_over(self):
+        # waiting for a tool from the start; at +200 its next request fails (a transient error,
+        # held by its spent budget, goes first); at +400 the user types and that reply streams
+        # until +900: waited for from +400, not from the tool's wait of before
+        t = int(self.t0)
+        hist = ",".join("transient:%d" % (t - 600 - i) for i in range(3))
+        w, r = self.start(main=self.idle() + [api_request(t - 60, "req_m2"),
+                                              block(t - 55, "req_m2", tool_use(), "tool_use")],
+                          hist=hist)
+        tpath = self.proj / (SID + ".jsonl")
+        r.at(t + 200, lambda: write(tpath, [result_of(t + 200), api_request(t + 200, "req_m3"),
+                                            cc_api_error(t + 201, "overloaded")]))
+        r.at(t + 400, lambda: write(tpath, [cc_user(t + 400, "try again please"),
+                                            api_request(t + 400, "req_m4")]))
+        r.at(t + 900, lambda: write(tpath, [block(t + 900, "req_m4", TEXT, "end_turn")]))
+        self.assertEqual(w.run(), 0)
+        term = self.term_at(r)
+        self.assertGreaterEqual(term[0], 900)
+        self.assertLess(term[0], 905)
+        self.assertEqual(self.relaunch_of(r)[0]["class"], "memory")
+
+    def test_a_compaction_after_a_long_hold_is_waited_for(self):
+        # /compact started after the verdict had been held for want of room has the cap of its
+        # own, counted from the first reading that showed its spinner
+        t = self.t0
+        w, r = self.start()
+        r.probe_out = "pick=acct-01 tier=hard\n"
+        r.at(t + 650, lambda: setattr(r, "screen", screen(spinner=COMPACTING)))
+        r.at(t + 660, lambda: setattr(r, "probe_out", "pick=acct-02 tier=eligible\n"))
+        r.at(t + 800, lambda: setattr(r, "screen", screen()))  # done; still over the line
+        self.assertEqual(w.run(), 0)
+        term = self.term_at(r)
+        self.assertGreaterEqual(term[0], 810)  # the first scan after it ended (every 30 s)
+        self.assertLess(term[0], 815)
+        self.assertIn(" reason=main-compact", [line for line in self.log_lines()
+                                               if " hold " in line][-1])
+        self.assert_relaunched(r)
+
+    def test_work_started_behind_a_transcript_verdict_is_waited_for(self):
+        # a transient error held by its budget goes first; the user types at +700, which ends
+        # it, and the reply to that is streamed for 500 s: the memory verdict waits for it
+        t = int(self.t0)
+        hist = ",".join("transient:%d" % (t - 600 - i) for i in range(3))
+        w, r = self.start(main=self.idle() + [cc_api_error(t, "overloaded")], hist=hist)
+        tpath = self.proj / (SID + ".jsonl")
+        r.at(t + 700, lambda: write(tpath, [cc_user(t + 700, "try again please"),
+                                            api_request(t + 700, "req_m4")]))
+        r.at(t + 1200, lambda: write(tpath, [block(t + 1200, "req_m4", TEXT, "end_turn")]))
+        self.assertEqual(w.run(), 0)
+        term = self.term_at(r)
+        self.assertGreaterEqual(term[0], 1200)
+        self.assertLess(term[0], 1205)
+        self.assertTrue([line for line in self.log_lines() if " reason=transient-budget" in line])
+        self.assertIn(" class=memory sid=%s acct=acct-01 reason=main-request" % SID,
+                      [line for line in self.log_lines() if " hold " in line][-1])
+        self.assertEqual(self.relaunch_of(r)[0]["class"], "memory")
+
+    def test_a_compaction_under_way_is_waited_for(self):
+        # /compact, the banner's other remedy, shows in no transcript while it runs: the
+        # spinner says it. Once it is over the banner decides: still up, the session moves...
+        t = self.t0
+        w, r = self.start()
+        r.screen = screen(spinner=COMPACTING)
+        r.at(t + 100, lambda: setattr(r, "screen", screen()))
+        self.assertEqual(w.run(), 0)
+        self.assertGreaterEqual(r.probes[0]["t"], t + 120)  # the first scan after it ended
+        self.assertLess(r.probes[0]["t"], t + 122)
+        self.assertEqual(self.events(), ["watch", "detect", "hold", "switch"])
+        self.assertIn(" class=memory sid=%s acct=acct-01 reason=main-compact" % SID,
+                      self.log_lines()[2])
+        self.assert_relaunched(r)
+        # ...gone (the heap back under the line), nothing does
+        w, r = self.start()
+        r.screen = screen(spinner=COMPACTING)
+        r.at(t + 100, lambda: setattr(r, "screen", screen(None)))
+        self.stop_at(r, t + 200)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        # ...and one longer than MEMORY_BUSY_CAP is not waited out
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_BUSY_CAP": "90"})
+        r.screen = screen(spinner=COMPACTING)
+        self.assertEqual(w.run(), 0)
+        self.assertGreaterEqual(r.probes[0]["t"], t + 90)
+        self.assertLess(r.probes[0]["t"], t + 95)
+        self.assert_relaunched(r)
+
+    def test_a_compact_started_during_the_probe_is_not_cut_off(self):
+        t = self.t0
+        w, r = self.start()
+        real_run = r.run
+
+        def run(argv, timeout, env=None, cwd=None):
+            if argv[0] == self.self_path:
+                r.screen = screen(spinner=COMPACTING)
+                r.at(r.t + 60, lambda: setattr(r, "screen", screen(None)))
+            return real_run(argv, timeout, env, cwd)
+        r.run = run
+        self.stop_at(r, t + 150)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+        self.assertIn(" reason=main-compact", self.log_lines()[-1])
+
+    def test_a_banner_gone_before_the_stop_moves_nothing(self):
+        # /compact while the probe runs: the look right before the stop finds no banner
+        w, r = self.start()
+        real_run = r.run
+
+        def run(argv, timeout, env=None, cwd=None):
+            if argv[0] == self.self_path:
+                r.screen = screen(None)
+            return real_run(argv, timeout, env, cwd)
+        r.run = run
+        self.stop_at(r, self.t0 + 60)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+        self.assertIsNone(w.memory)
+        # gone while the main thread is still busy: the next scan ends the verdict, and the
+        # tool finishing later moves nothing
+        t = self.t0
+        w, r = self.start(main=self.idle() + [api_request(t - 60, "req_m2"),
+                                              block(t - 55, "req_m2", tool_use(), "tool_use")])
+        r.at(t + 20, lambda: setattr(r, "screen", screen(None)))
+        r.at(t + 40, lambda: self.transcript([result_of(t + 40)]))
+        self.stop_at(r, t + 120)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+
+    def test_a_banner_back_after_it_went_is_a_new_verdict(self):
+        t = self.t0
+        w, r = self.start()
+        r.screen = screen(None)
+        r.at(t + 50, lambda: setattr(r, "screen", screen()))
+        self.assertEqual(w.run(), 0)
+        self.assertGreaterEqual(r.probes[0]["t"], t + 65)  # seen at the +60 scan, then GRACE
+        self.assertLess(r.probes[0]["t"], t + 67)
+        self.assert_relaunched(r)
+
+    def test_a_banner_back_after_it_went_is_held_and_probed_afresh(self):
+        # held for want of room at +5, gone at the +30 scan, back at the +60 one: the new
+        # verdict is probed GRACE after it (not HOLD_REPROBE after the old one's probe), and
+        # its own hold is logged
+        t = self.t0
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_HOLD_REPROBE": "120"})
+        r.probe_out = "pick=acct-01 tier=hard\n"
+        r.at(t + 20, lambda: setattr(r, "screen", screen(None)))
+        r.at(t + 50, lambda: setattr(r, "screen", screen()))
+        self.stop_at(r, t + 100)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual([round(p["t"] - t) for p in r.probes], [5, 65])
+        self.assertEqual(self.events(), ["watch", "detect", "hold", "detect", "hold"])
+        self.assertIn(" class=memory sid=%s acct=acct-01 reason=no-room" % SID,
+                      self.log_lines()[-1])
+        self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+
+    def test_at_most_memory_per_hour_then_the_watch_gives_up_on_it(self):
+        # two memory relaunches of this chain in the last hour: this process is left as it is,
+        # once, and the watcher goes on with the transcript's own verdicts
+        t = int(self.t0)
+        hist = "memory:%d,memory:%d" % (t - 3000, t - 1200)
+        w, r = self.start(hist=hist)
+        tpath = self.proj / (SID + ".jsonl")
+        r.at(t + 60, lambda: write(tpath, [cc_quota(t + 60, resets=t + 9000)]))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(self.events(), ["watch", "detect", "giveup", "detect", "switch"])
+        self.assertIn(" reason=memory-budget sid=%s acct=acct-01 class=memory" % SID,
+                      self.log_lines()[2])
+        self.assertEqual(len(r.probes), 1)
+        self.assertGreaterEqual(r.probes[0]["t"], t + 65)
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["hist"].split(",")[:2]), ("quota", hist.split(",")))
+        self.assertEqual(len(r.captures), 1)  # the scan that found it, and none after
+
+    def test_a_client_that_ignores_sigterm_still_gets_its_relaunch(self):
+        # 2026-10-20: a client at 8.3GB ignored SIGTERM for over 15 s. KILL after TERM_GRACE;
+        # the relaunch is typed once it is gone, however long it then takes to go
+        for after_kill in (0, 6):
+            with self.subTest(after_kill=after_kill):
+                w, r = self.start()
+                r.term_kills = False
+                real_signal = r.signal
+
+                def slow_kill(pid, sig, r=r, real_signal=real_signal, after_kill=after_kill):
+                    if pid == self.PID and sig == signal.SIGKILL and after_kill:
+                        r.stuck.add(pid)  # the kernel takes its time tearing 8 GB down
+                        r.at(r.t + after_kill, lambda: (r.stuck.discard(pid), r.exit(pid)))
+                    return real_signal(pid, sig)
+                r.signal = slow_kill
+                self.assertEqual(w.run(), 0)
+                self.assertEqual(r.signals, [(self.PID, signal.SIGTERM),
+                                             (self.PID, signal.SIGKILL)])
+                term = r.index(lambda a: a[:3] == ["<signal>", self.PID, signal.SIGTERM])
+                kill = r.index(lambda a: a[:3] == ["<signal>", self.PID, signal.SIGKILL])
+                typed = r.index(lambda a: a[0] == "tmux" and "-l" in a)
+                self.assertGreaterEqual(r.calls[kill]["t"], r.calls[term]["t"] + 10)  # TERM_GRACE
+                self.assertGreaterEqual(r.calls[typed]["t"], r.calls[kill]["t"] + after_kill)
+                self.assert_sequence(r)
+                self.assert_relaunched(r)
+                self.assertEqual(self.events()[-1], "switch")
+
+    def test_a_client_that_takes_its_time_on_sigterm_is_waited_for(self):
+        w, r = self.start()
+        r.term_kills = False
+        real_signal = r.signal
+
+        def slow_term(pid, sig):
+            if pid == self.PID and sig == signal.SIGTERM:
+                r.at(r.t + 8, lambda: r.exit(pid))  # flushes its workflows' state, then goes
+            return real_signal(pid, sig)
+        r.signal = slow_term
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(r.signals, [(self.PID, signal.SIGTERM)])
+        self.assert_sequence(r)
+        self.assert_relaunched(r)
+
+    def test_a_pane_that_is_not_the_clients_screen_is_never_read(self):
+        for name, setup in (("in the background", lambda r: setattr(r, "client_stat", "S")),
+                            ("suspended", lambda r: setattr(r, "client_stat", "T+")),
+                            ("another pane", lambda r: setattr(r, "pane_pid", 31337))):
+            with self.subTest(name):
+                w, r = self.start()
+                setup(r)
+                self.stop_at(r, self.t0 + 100)
+                self.assertEqual(w.run(), 0)
+                self.assert_untouched(r)
+                self.assertEqual(r.captures, [])
+
+    def test_a_session_the_relaunch_cannot_name_is_not_read(self):
+        state = self.write_state(["--dangerously-skip-permissions"])
+        w, r = self.watcher(state, None, MemoryRunner(self.t0, self.PID, self.PPID,
+                                                       self.self_path))
+        r.at(self.t0 + 70, lambda: r.exit(self.PID))  # no registry: no session id
+        self.assertEqual(w.run(), 0)
+        self.assertEqual((r.captures, r.probes), ([], []))
+
+    def test_the_transcripts_verdict_goes_first(self):
+        t = int(self.t0)
+        w, r = self.start(main=self.idle() + [cc_quota(t, resets=t + 9000)])
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 1)
+        kv, _ = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["avoid"]), ("quota", "acct-01:%d" % (t + 9000)))
+        self.assertEqual(self.events(), ["watch", "detect", "detect", "switch"])
+        self.assertIn(" class=quota ", self.log_lines()[-1])
+        # a transient error's ladder holds it back for 30 s: the memory verdict, older and
+        # ready, waits behind it all the same (one relaunch, the transcript's)
+        w, r = self.start(main=self.idle() + [cc_api_error(t, "overloaded")])
+        r.probe_out = "pick=acct-01 tier=soft\n"
+        self.assertEqual(w.run(), 0)
+        self.assertGreaterEqual(r.probes[0]["t"], t + 30)
+        self.assertEqual(self.relaunch_of(r)[0]["class"], "transient")
+
+    def test_a_limit_read_during_the_memory_probe_goes_first(self):
+        # The account's limit is written while the memory verdict's probe runs. The check
+        # right before the stop finds it: the memory verdict stands aside, the pane is not
+        # read again, and the session moves for the limit, its account avoided until the reset
+        t = int(self.t0)
+        w, r = self.start()
+        tpath = self.proj / (SID + ".jsonl")
+        real_run = r.run
+
+        def run(argv, timeout, env=None, cwd=None):
+            if argv[0] == self.self_path and not r.probes:
+                write(tpath, [cc_quota(t + 5, resets=t + 9000)])
+            return real_run(argv, timeout, env, cwd)
+        r.run = run
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(len(r.probes), 2)  # the memory verdict's, then the limit's
+        self.assertEqual(len(r.captures), 1)  # the scan that found the banner, and no other
+        self.assertEqual(r.signals, [(self.PID, signal.SIGTERM)])
+        kv, argv = self.relaunch_of(r)
+        self.assertEqual((kv["class"], kv["avoid"]), ("quota", "acct-01:%d" % (t + 9000)))
+        self.assertEqual(argv[-1], ar.resume_prompt("quota"))
+        self.assertEqual(self.events(), ["watch", "detect", "detect", "switch"])
+        self.assertIn(" class=quota ", self.log_lines()[-1])
+
+    def test_the_transcript_is_read_to_its_end_before_the_main_thread_counts_as_idle(self):
+        # A resumed session's transcript takes several reads. The first ones end on a turn
+        # that finished; its end has a tool still running, and that is what the memory
+        # verdict waits for, not the idle turn the reads so far end on
+        t = self.t0
+        filler = [cc_reply(self.launched + 30 + i, "y" * 2000) for i in range(60)]
+        w, r = self.start(main=self.idle() + filler + [
+            api_request(t - 60, "req_m2"), block(t - 55, "req_m2", tool_use(), "tool_use")])
+        r.at(t + 240, lambda: self.transcript([result_of(t + 240)]))
+        with mock.patch.object(ar.JsonlTail, "MAX_READ", 4096):
+            self.assertEqual(w.run(), 0)
+        term = self.term_at(r)
+        self.assertEqual(len(term), 1)
+        self.assertGreaterEqual(term[0], 240)
+        self.assertLess(term[0], 245)
+        self.assertEqual(self.events(), ["watch", "detect", "hold", "switch"])
+        self.assertIn(" class=memory sid=%s acct=acct-01 reason=main-tool" % SID,
+                      self.log_lines()[2])
+        self.assert_relaunched(r)
+
+    def test_a_banner_that_comes_and_goes_never_re_probes_a_transcript_verdict(self):
+        # A limit held for want of room is probed again every HOLD_REPROBE (60 s), its hold
+        # logged once. A banner up on one scan and gone on the next (a heap near the line), or
+        # a pane read that fails every other scan, used to re-arm it each time: a probe and a
+        # hold line every 30 s. Only the memory verdict's own state comes and goes with it
+        t = int(self.t0)
+        for flip in ("banner", "read"):
+            with self.subTest(flip):
+                w, r = self.start(main=self.idle() + [cc_quota(t, resets=t + 9000)])
+                r.probe_out = "pick=acct-01 tier=hard\n"
+                real_run = r.run
+
+                def run(argv, timeout, env=None, cwd=None, r=r, real_run=real_run, flip=flip):
+                    rc, out = real_run(argv, timeout, env, cwd)
+                    if argv[0] == "tmux" and "capture-pane" in argv and len(r.captures) % 2 == 0:
+                        return (1, "") if flip == "read" else (0, screen(None))
+                    return rc, out
+                r.run = run
+                self.stop_at(r, t + 300)
+                self.assertEqual(w.run(), 0)
+                self.assertEqual([round(p["t"] - t) for p in r.probes], [5, 65, 125, 185, 245])
+                holds = [line for line in self.log_lines() if " hold " in line]
+                self.assertEqual(len(holds), 1)
+                self.assertIn(" class=quota sid=%s acct=acct-01 reason=no-room" % SID, holds[0])
+                self.assertEqual(len([line for line in self.log_lines()
+                                      if " detect " in line and " class=memory " in line]), 5)
+                self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+
+    REFUSALS = ("pane-shell", "pgrp", "holder", "sync", "mode", "cwd", "write", "pane",
+                "background")
+
+    def refusing(self, r, why):
+        """Make the check ``why`` refuse the stop; returns what undoes it. The pane and the
+        foreground turn bad only right after the look before the stop: memory_reading checks
+        both itself, so earlier they would end the verdict before it ever got to a stop."""
+        if why == "pane-shell":
+            r.shell_comm = "fish"
+            return lambda: setattr(r, "shell_comm", "-zsh")
+        if why == "pgrp":
+            r.live.add(self.PPID)
+            r.pgids[self.PID] = self.PPID
+            return lambda: r.pgids.pop(self.PID)
+        if why == "holder":
+            other = self.root / "acct-02" / "sessions" / "6060.json"
+            other.write_text(json.dumps({"pid": 6060, "sessionId": SID, "cwd": str(self.work),
+                                         "startedAt": self.launched * 1000 + 700}))
+            r.live.add(6060)
+            r.starts[6060] = time.strftime("%a %b %d %H:%M:%S %Y", time.localtime(self.launched))
+            return lambda: (r.live.discard(6060), other.unlink())
+        if why == "sync":
+            r.pane_sync = 1
+            return lambda: setattr(r, "pane_sync", 0)
+        if why == "mode":
+            r.pane_mode, r.mode_sticky = 2, True
+            return lambda: setattr(r, "mode_sticky", False)
+        if why == "cwd":
+            self.work.rmdir()
+            return self.work.mkdir
+        if why == "write":
+            return lambda: None  # write_relaunch fails once (the test's patch)
+        real_run = r.run
+
+        def run(argv, timeout, env=None, cwd=None):
+            out = real_run(argv, timeout, env, cwd)
+            if argv[0] == "tmux" and "capture-pane" in argv and len(r.captures) == 2:
+                if why == "pane":
+                    r.pane_pid = 31337
+                else:
+                    r.client_stat = "T+"
+            return out
+        r.run = run
+        return lambda: (setattr(r, "pane_pid", self.PPID), setattr(r, "client_stat", "S+"))
+
+    def test_a_check_that_refuses_the_stop_drops_only_the_memory_verdict(self):
+        # A check before the stop refuses it (+5): the memory verdict alone is given up, once,
+        # and the pane is not read for MEMORY_BACKOFF (600 s). The watcher used to exit there,
+        # and with it the session's every other watch: the limit at +100 moves it all the same
+        t = int(self.t0)
+        tpath = self.proj / (SID + ".jsonl")
+        real_write = ar.write_relaunch
+        for why in self.REFUSALS:
+            with self.subTest(why):
+                self.work.mkdir(exist_ok=True)  # whatever an earlier case left
+                w, r = self.start()
+                undo = self.refusing(r, why)
+                r.at(t + 60, undo)
+                r.at(t + 100, lambda: write(tpath, [cc_quota(t + 100, resets=t + 9000)]))
+                writes = []
+
+                def flaky_write(*args, why=why, writes=writes):
+                    writes.append(args)
+                    if why == "write" and len(writes) == 1:
+                        raise OSError("No space left on device")
+                    return real_write(*args)
+                with mock.patch.object(ar, "write_relaunch", flaky_write):
+                    self.assertEqual(w.run(), 0)
+                self.assertEqual(self.events(), ["watch", "detect", "giveup", "detect", "switch"])
+                self.assertIn(" giveup provider=claude chain=%s reason=memory-%s sid=%s "
+                              "acct=acct-01 %sclass=memory" % (w.chain, why, SID,
+                                                               "holder=6060 " if why == "holder"
+                                                               else ""), self.log_lines()[2])
+                self.assertIsNone(w.memory)
+                # the pane read by the scan and once more right before the stop (the directory
+                # is looked for before the probe: the scan alone), and never in the backoff
+                self.assertEqual(len(r.captures), 1 if why == "cwd" else 2)
+                self.assertEqual(len(r.probes), 1 if why == "cwd" else 2)
+                self.assertEqual(r.signals, [(self.PID, signal.SIGTERM)])
+                kv, argv = self.relaunch_of(r)
+                self.assertEqual((kv["class"], kv["avoid"]), ("quota", "acct-01:%d" % (t + 9000)))
+                self.assertGreaterEqual(self.term_at(r)[0], 100)
+
+    def test_after_a_refusal_the_pane_is_read_again_once_the_backoff_is_over(self):
+        # synchronized panes refuse the stop at +5 and are turned off at +60; with
+        # MEMORY_BACKOFF 120 the pane is read again at +125, and that verdict moves it at +130
+        t = self.t0
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_BACKOFF": "120"})
+        r.pane_sync = 1
+        r.at(t + 60, lambda: setattr(r, "pane_sync", 0))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual([round(c["t"] - t) for c in r.captures], [0, 5, 125, 130])
+        self.assertEqual(self.events(), ["watch", "detect", "giveup", "detect", "switch"])
+        self.assert_relaunched(r)
+
+    def test_a_refusal_that_lasts_is_logged_once_a_verdict_and_a_limit_still_gives_up(self):
+        # Synchronized panes for good: each memory verdict (+0, +125, +250, +375 with
+        # MEMORY_BACKOFF 120) is probed once and refused once, one line each. A limit refused
+        # the same way still ends the watch, as it always has
+        t = int(self.t0)
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_BACKOFF": "120"})
+        r.pane_sync = 1
+        tpath = self.proj / (SID + ".jsonl")
+        r.at(t + 400, lambda: write(tpath, [cc_quota(t + 400, resets=t + 9000)]))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(self.events(), ["watch"] + ["detect", "giveup"] * 5)
+        refused = [line for line in self.log_lines() if " reason=memory-sync " in line]
+        self.assertEqual(len(refused), 4)
+        self.assertEqual([round(p["t"] - t) for p in r.probes], [5, 130, 255, 380, 405])
+        self.assertIn(" giveup provider=claude chain=%s reason=sync sid=%s class=quota"
+                      % (w.chain, SID), self.log_lines()[-1])
+        self.assertEqual((r.signals, r.sends, self.relaunch_files()), ([], [], []))
+
+    def test_the_scan_is_paced_and_can_be_turned_off(self):
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_SCAN": "10"})
+        r.screen = screen(None)
+        self.stop_at(r, self.t0 + 95)
+        self.assertEqual(w.run(), 0)
+        self.assertEqual([round(c["t"] - self.t0) for c in r.captures], list(range(0, 91, 10)))
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_SCAN": "0"})
+        self.stop_at(r, self.t0 + 95)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(r.captures, [])
+
+    def test_the_process_backstop_is_opt_in(self):
+        gib = 1 << 30
+        w, r = self.start()
+        r.screen, r.used = screen(None), 13 * gib
+        self.stop_at(r, self.t0 + 100)
+        self.assertEqual(w.run(), 0)
+        self.assert_untouched(r)
+        self.assertEqual(r.footprints, 0)  # off by default: never even read
+        w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_LIMIT_MB": "12000"})
+        r.screen, r.used = screen(None), 13 * gib
+        self.assertEqual(w.run(), 0)
+        self.assert_relaunched(r, size="13GB")
+        self.assertIn(" code=memory_limit sid=%s acct=acct-01 reset=- size=13GB src=process" % SID,
+                      self.log_lines()[1])
+        # under the limit, or unreadable: nothing
+        for used in (11 * gib, None):
+            w, r = self.start(env={"CLAUDE_MULTIACC_AR_MEMORY_LIMIT_MB": "12000"})
+            r.screen, r.used = screen(None), used
+            self.stop_at(r, self.t0 + 60)
+            self.assertEqual(w.run(), 0)
+            self.assert_untouched(r)
+
+    def test_codex_never_reads_its_pane(self):
+        # a codex session past MEMORY_MIN_UPTIME, its rollout found, the backstop on: the
+        # client is not claude, and neither its pane nor its memory is ever read
+        for acct in ("acct-01", "acct-02"):
+            os.rmdir(str(self.root / acct / "sessions"))
+            os.symlink(str(self.shared / "sessions"), str(self.root / acct / "sessions"))
+        day = self.shared / "sessions" / "2026" / "10" / "20"
+        day.mkdir(parents=True)
+        (day / ("rollout-2026-10-20T08-00-00-%s.jsonl" % CX_SID)).write_text(
+            jl([cx_meta(self.launched + 5, cwd=str(self.work))]))
+        state = self.write_state(["--yolo", "resume", CX_SID], provider="codex")
+        w, r = self.watcher(state, {"CODEX_MULTIACC_AR_MEMORY_LIMIT_MB": "1"},
+                            MemoryRunner(self.t0, self.PID, self.PPID, self.self_path))
+        r.used = 1 << 34
+        r.at(self.t0 + 70, lambda: r.exit(self.PID))
+        self.assertEqual(w.run(), 0)
+        self.assertEqual(w.sid, CX_SID)
+        self.assertEqual((r.captures, r.footprints, r.probes), ([], 0, []))
+
+
+class FootprintTests(unittest.TestCase):
+    @unittest.skipUnless(sys.platform == "darwin" or os.path.isdir("/proc/self"),
+                         "no footprint source on this platform")
+    def test_reads_this_process_and_nothing_for_a_pid_that_is_not_there(self):
+        runner = ar.Runner()
+        used = runner.footprint(os.getpid())
+        self.assertIsNotNone(used)
+        self.assertGreater(used, 1 << 20)
+        self.assertLess(used, 1 << 40)
+        self.assertIsNone(runner.footprint(4999999))
+
+
+if __name__ == "__main__":
+    unittest.main()