claude-multiacc 2.0.57 → 2.0.59

package/lib/autoresume.py

@@ -6,12 +6,15 @@ idles on "continuing automatically at <reset>" (which can be days away) and code
 "You've hit your usage limit ... try again at <date>", both waiting for a human. The shim
 (bin/claude, bin/codex) spawns this watcher, detached, right before its
 ``exec`` of an interactive TUI inside tmux. The watcher tails that session's own
-transcript (claude) or rollout (codex) and, on a verdict it can act on:
+transcript (claude: its subagents' and workflow agents' transcripts too) or rollout (codex)
+— a claude watcher also reads its own pane, read-only, for the client's critical-memory
+banner, which no transcript records — and, on a verdict it can act on:
 
 1. asks the SHIM which account a relaunch would get (probe mode: the real candidate loop,
    ``pick=<acct> tier=<t>``, never an exec) — so it only stops a session there is
    somewhere to move to;
-2. writes a single-use relaunch file (verdict + argv + chain state);
+2. writes a single-use relaunch file (verdict + argv + chain state); the argv pins the model
+   and effort the session itself last ran with, read from its history right then;
 3. stops the client with SIGTERM (SIGKILL after a grace);
 4. waits for the pane to be back at its SHELL and types
    `` CLAUDE_MULTIACC_AR=<token>:<sid> [CLAUDE_ACCOUNTS_ROOT=<root>] <shim path>`` there.
@@ -49,11 +52,13 @@ import shutil
 import signal
 import stat
 import string
+import struct
 import subprocess
 import sys
 import tempfile
 import time
 import traceback
+from collections import deque
 
 # -I omits the script directory; load only helpers from this installation.
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
@@ -61,6 +66,9 @@ from autoresume_probe import ACCT_RE, ROTATE, parse_probe, probe_allows, probe_e
 from autoresume_receipt import apply_cursor, confirm_prompt, receipt_tail
 from autoresume_cross import chain_fields, plan_fallback, prepare as prepare_cross
 from autoresume_cross_receipt import confirm_cross
+from model_catalog import load as load_catalog, parse_id
+from model_match import resume_settings, settings_flags
+from session_settings import session_settings
 
 # ---- vocabulary ---------------------------------------------------------------------
 
@@ -84,6 +92,7 @@ REASONS = {
     "blocked": "the previous account was refused",
     "transient": "an API error ended the last turn",
     "crash": "the previous process exited unexpectedly",
+    "memory": "the previous process reached critical memory usage",
 }
 
 # How long the chain keeps away from the account it is leaving. quota uses the server's
@@ -92,6 +101,10 @@ AVOID_SECONDS = {"auth": 3600, "blocked": 6 * 3600, "model": 5 * 3600}
 QUOTA_FALLBACK = 3600
 
 CLAUDE_QUOTA_TYPES = ("five_hour", "seven_day")
+# "concurrents": the account turned away a request among too many in flight at once. A
+# moment's throttle, not one model's bucket: on 2026-10-20 acct-02 refused 54 so between
+# 12:36:50 and 12:39:44 while serving 700+ requests a minute, so the next one goes through.
+CLAUDE_THROTTLE_TYPES = ("concurrents",)
 CLAUDE_TRANSIENT = ("overloaded", "server_error", "unknown")
 CLAUDE_BLOCKED = ("oauth_org_not_allowed", "account_on_hold", "billing_error",
                   "verification_required")
@@ -100,6 +113,24 @@ CLAUDE_BLOCKED = ("oauth_org_not_allowed", "account_on_hold", "billing_error",
 MODEL_TEXT = re.compile(r"reached your .{0,40} limit|switch to another model", re.I)
 # User records that are machinery, not a human at the keyboard.
 NON_HUMAN_PREFIXES = ("<task-notification", "<local-command", "<system-reminder")
+# A slash command as the client records it: a user record whose text starts with one of
+# these, naming the command in <command-name>/model</command-name>. A human at the keyboard,
+# but one running a command that only shows or configures the session (INERT_COMMANDS)
+# handles a model's limit or a failed turn that way (/model), never the account's: that is
+# just as limited afterwards (sessions 5 and 8 ran /model, 2026-10-19). Any other command
+# may be what fixed the account (/login, /limit-reset, /usage-credits, /upgrade, /config's
+# settings ...): it counts as the user typing. Names and aliases as claude 2.1.303 has them.
+COMMAND_PREFIXES = ("<command-name>", "<command-message>")
+COMMAND_NAME_RE = re.compile(r"<command-name>\s*/?([A-Za-z0-9:._-]{1,64})\s*</command-name>")
+INERT_COMMANDS = frozenset((
+    "model", "effort", "usage", "cost", "stats", "status", "context", "help", "mcp", "plugin",
+    "plugins", "reload-plugins", "doctor", "memory", "permissions", "agents", "hooks", "ide",
+    "skills", "theme", "statusline", "output-style", "keybindings", "vim", "terminal-setup",
+    "export", "copy", "todos", "tasks", "bashes", "add-dir", "release-notes"))
+# Verdicts about the whole ACCOUNT, not one model or one turn: the only ones a subagent's or
+# workflow agent's transcript can report for the session, and the ones no inert slash
+# command ends.
+ACCOUNT_CLASSES = ("quota", "auth", "blocked")
 
 CODEX_QUOTA = ("usage_limit_exceeded", "rate_limit_exceeded")
 CODEX_AUTH = ("unauthorized",)
@@ -119,6 +150,14 @@ TOKEN_RE = re.compile(r"^[A-Za-z0-9]{8,64}$")
 CLASS_RE = re.compile(r"^[a-z_]{1,16}$")
 # What the relaunch line may carry unquoted (the shims' gate refuses anything else).
 TYPEABLE_RE = re.compile(r"^/[A-Za-z0-9/._+-]*$")
+# What a relaunch may pin from the session's own history: a model id (context suffixes like
+# [1m] and provider-qualified ids included) and an effort level — [a-z]+ is also what
+# bin/codex's gate accepts after `-c model_reasoning_effort=`.
+MODEL_VALUE_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:/@+\[\]-]{0,199}\Z")
+EFFORT_VALUE_RE = re.compile(r"^[a-z]+\Z")
+CODEX_EFFORT_KEY = "model_reasoning_effort="
+CLAUDE_FAMILY_ALIASES = ("sonnet", "opus", "haiku", "fable")
+CONTEXT_SUFFIX_RE = re.compile(r"\[\d+[km]\]$", re.I)
 ISO_RE = re.compile(r"^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?"
                     r"(Z|[+-]\d{2}:?\d{2})?$")
 TRY_AGAIN_RE = re.compile(
@@ -127,20 +166,85 @@ TRY_AGAIN_RE = re.compile(
 MONTHS = {m: i for i, m in enumerate(
     ("jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"), 1)}
 
+# claude 2.1.304 reads its heap every 10 s (process.memoryUsage().heapUsed), and from 2.5 GiB
+# on shows, red, in the notification column of the prompt's footer: at the right of the mode
+# line when the row has room, on the footer's next row (the column wraps) when it has not,
+# the text itself cut with an ellipsis, never wrapped:
+#   Critical memory usage (8.3GB) — restart and resume with claude --continue, or run /compact
+# It writes nothing of it to the transcript. The size is the client's own format (one
+# decimal, ".0" dropped). After it comes MEMORY_TAIL with its em dash, whole, or as much of it
+# as fits and the ellipsis Ink's truncation ends it with -- a hyphen or an en dash is never the
+# client's. The banner is the last line of the notification column, so nothing follows it on
+# its row but what the client draws right of that column (MEMORY_AFTER_RE). Nothing is
+# required before it: in a pane too narrow for the row, the column it is in can abut the mode
+# line, cut to an ellipsis of its own.
+MEMORY_BANNER_RE = re.compile(r"Critical memory usage \((\d{1,7}(?:\.\d)?(?:KB|MB|GB)"
+                              r"|\d{1,10} bytes)\)")
+MEMORY_TAIL = " — restart and resume with claude --continue, or run /compact"
+MEMORY_TAIL_MIN = len(" — restart and resume with claude --continue")  # ", or run…" is optional
+# Right of the notification column, on its last row, 2.1.304 draws only a stashed prompt's pill
+# (" · › stashed", or " › stashed" when no notification is up) and an active goal's ("◎ /goal
+# active (5m)", " · " before it after any other item), each only while there is one; then the
+# row ends.
+MEMORY_AFTER_RE = re.compile(r"(?:(?: · | )› stashed)?(?:(?: · )?◎ /goal active"
+                             r"(?: \([^()]{1,16}\))?)?")
+# A row of the background-task list under the footer (2.1.304's, after a blank row): the
+# selection pointer (❯, > where it cannot be drawn) or two spaces, an agent's tree connector
+# (├ └, two columns further in a level), then the task's bullet -- ◯ (( ) where it cannot be
+# drawn), ⏺ or ● for the one viewed, ⏸ for a paused workflow -- and a space. Its name and
+# description are the model's own words, so such a row is never read for the banner -- but
+# for the footer's first row, which is always the client's own (its status line, whatever that
+# starts with, or its mode line): the task list comes after the footer.
+TASK_ROW_RE = re.compile(r"(?:  |[❯>] )(?:(?:  )*[├└] )?(?:[◯⏺●⏸]|\( \)) ")
+# The prompt's box, the one place on screen the client's own status hangs from (2.1.304,
+# inline: the pool's accounts run with "tui": "default"): a rule across the pane from its first
+# column; right under it the prompt's row, the client's mode indicator in that first column
+# (❯, ! in shell mode, > where ❯ cannot be drawn, or the agent a teammate view names) and its
+# no-break space; the input's other rows, indented past the indicator; the rule closing it,
+# from the first column again. The footer is the rows right under that rule, down to the first
+# blank row (the background-task list starts after one). A dialog drawn in the box's place is
+# framed by one rule on top, its title and body indented under it: no prompt row, so no box,
+# and nothing it quotes counts. Neither does anything above the box (the conversation) or in
+# it (what the user is typing).
+RULE_RE = re.compile(r"[─━]{8,}")
+PROMPT_ROW_RE = re.compile(r"[^\s\xa0][^\xa0]{0,24}\xa0")
+# How far under the prompt's row the rule closing the box may be (the draft's rows): a box
+# holding a taller draft is not read.
+PROMPT_ROWS = 40
+# How far above the box the compaction spinner is looked for (it sits right above the box,
+# under the todo list when one is shown).
+MEMORY_ROWS = 40
+# The client's spinner above the prompt's box while it compacts the conversation (2.1.304:
+# "Compacting conversation…"): /compact, the banner's other remedy, under way. The transcript
+# shows nothing of it until it is done (a compact_boundary record).
+COMPACTING = "Compacting conversation"
+# capture-pane -p prints the screen's text alone, but a stray sequence (or a fake) is no reason
+# to miss the banner: escape sequences and C0/C1 controls are dropped before matching.
+ANSI_RE = re.compile(r"\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)?|[@-Z\\-_])")
+CONTROL_RE = re.compile(r"[\x00-\x08\x0b-\x1f\x7f-\x9f]")
+
 STATE_KEYS = ("v", "provider", "pid", "ppid", "acct", "acct_dir", "cwd", "launched", "tmux",
               "pane", "self", "acc_root", "depth", "avoid", "hist", "chain", "funding_tier",
-              "rollout_cursor", "avoid_claude", "avoid_codex", "pool_claude", "pool_codex", "handoff_token")
+              "rollout_cursor", "avoid_claude", "avoid_codex", "pool_claude", "pool_codex", "handoff_token",
+              "via")
 RELAUNCH_KEYS = ("v", "provider", "class", "acct", "reset", "rtype", "marked", "sid", "cwd",
                  "depth", "avoid", "hist", "chain", "funding_tier", "funding_pid", "rollout_cursor",
-                 "avoid_claude", "avoid_codex", "pool_claude", "pool_codex", "handoff_token", "cross")
+                 "avoid_claude", "avoid_codex", "pool_claude", "pool_codex", "handoff_token", "cross",
+                 "model", "via")
 HIST_KEEP = 32
 
 # ---- knobs --------------------------------------------------------------------------
 # Every timing constant is overridable as <P>_MULTIACC_AR_<NAME> (P = CLAUDE or CODEX) so
-# the suites can run the whole stop/relaunch sequence in a second. The last five are not
+# the suites can run the whole stop/relaunch sequence in a second. The last ones are not
 # in the spec's list; they bound waits the spec fixes (probe 30 s, rollout discovery
-# 5 min, subagent quiet 20 s capped at 15 min, the typed relaunch taking effect 10 s) and
-# exist for the same reason.
+# 5 min, subagent quiet 20 s capped at 15 min, the typed relaunch taking effect 10 s), or
+# pace the look for new subagent transcripts (5 s), and exist for the same reason. The
+# MEMORY_* ones pace and bound the claude watcher's look at its pane for the client's
+# critical-memory banner (watch_memory): a read every MEMORY_SCAN s (0 turns it off), none
+# before the launch is MEMORY_MIN_UPTIME old, the main thread's work waited for up to
+# MEMORY_BUSY_CAP, at most MEMORY_PER_HOUR such relaunches a chain an hour, none for
+# MEMORY_BACKOFF s after a check before the stop refused one (refuse), and -- only when set --
+# the client's own memory at MEMORY_LIMIT_MB or more counting as well.
 KNOBS = {
     "POLL": 1.0,
     "GRACE": 5.0,
@@ -158,6 +262,13 @@ KNOBS = {
     "SUBAGENT_CAP": 900.0,
     "RELAUNCH_WAIT": 10.0,
     "PROMPT_WAIT": 30.0,
+    "SUBAGENT_SCAN": 5.0,
+    "MEMORY_SCAN": 30.0,
+    "MEMORY_MIN_UPTIME": 900.0,
+    "MEMORY_BUSY_CAP": 600.0,
+    "MEMORY_PER_HOUR": 2,
+    "MEMORY_BACKOFF": 600.0,
+    "MEMORY_LIMIT_MB": 0,
 }
 LADDER_DEFAULT = (30.0, 60.0, 120.0)
 # After DISCOVER_TIMEOUT a codex watcher still looks for its rollout (a session first
@@ -170,6 +281,26 @@ MAX_TREE = 64          # more "descendants" than this is not one TUI's tree: kil
 # The cwd fallback is for a machine that cannot list open files; a lookup that is there
 # but has failed this long counts as not there.
 LOOKUP_FAILED = 30.0
+# A claude session's subagents (the Agent tool) and workflow agents write transcripts of
+# their own (<sid>/subagents/**/agent-*.jsonl), and a limit that stops them may be recorded
+# nowhere else (sessions 5 and 8, 2026-10-19). They are looked for every SUBAGENT_SCAN s, in
+# a walk of at most SIDE_SCAN entries. Only the SIDE_FILES written most recently are
+# followed, and they share SIDE_BYTES per tick: a session with hundreds of agents, some past
+# 15 MB, cannot stall the one-second loop.
+SIDE_SCAN = 5000
+SIDE_FILES = 128
+SIDE_BYTES = 16 << 20
+# One last written this long before the launch holds nothing of it: followed from its end.
+SIDE_SLACK = 5.0
+# A subagent's rejection counts only this long after the tracker's `since` (the launch less
+# the main thread's two seconds of slack): from a second past the launch `date +%s` floored.
+# A relaunch replaces a process whose workflow agents met the limit in bursts that span
+# seconds, up to the moment it was gone, just before this launch; this launch's own agents
+# start only after its first request.
+SIDE_AFTER = 3.0
+# The newest main-transcript lines a claude watcher keeps (main_thread_busy reads them): an
+# agent's verdict waits while the main thread's own request, stream or tool is in flight.
+MAIN_RECENT_BYTES = 4 << 20
 
 
 def _knob(raw, default):
@@ -349,6 +480,10 @@ def budget_check(cls, depth, hist, now, cfg):
         used = sum(1 for c, t in entries if c == "crash" and now - t < 600)
         if used >= cfg.crash_per_10min:
             return False, "crash-budget"
+    elif cls == "memory":
+        used = sum(1 for c, t in entries if c == "memory" and now - t < 3600)
+        if used >= cfg.memory_per_hour:
+            return False, "memory-budget"
     return True, ""
 
 
@@ -383,28 +518,34 @@ def _message_text(rec):
 
 
 def claude_human_input(rec, prefixes=(PROMPT_PREFIX,)):
-    """True for a main-thread user record a HUMAN produced (typed text, a slash command,
-    a pasted image) — never a tool result, meta/compaction record, a harness
+    """What a main-thread user record a HUMAN produced is: "command" for a slash command
+    that only shows or configures the session (INERT_COMMANDS: /model, /usage ...), "user"
+    for anything else typed or pasted (text, an image, any other command: /login,
+    /limit-reset ...). None for a tool result, a meta/compaction record, a harness
     notification, or the watcher's own auto-resume prompt."""
     if rec.get("isMeta") is True or rec.get("isCompactSummary") is True \
             or rec.get("isVisibleInTranscriptOnly") is True or "toolUseResult" in rec:
-        return False
+        return None
     msg = rec.get("message")
     content = msg.get("content") if isinstance(msg, dict) else None
     if isinstance(content, list):
         blocks = [b for b in content if isinstance(b, dict)]
         if not blocks or any(b.get("type") == "tool_result" for b in blocks):
-            return False
+            return None
         text = " ".join(b.get("text") for b in blocks
                         if b.get("type") == "text" and isinstance(b.get("text"), str))
     elif isinstance(content, str):
         text = content
     else:
-        return False
+        return None
     head = text.lstrip()
-    if head.startswith(NON_HUMAN_PREFIXES):
-        return False
-    return not any(p and head.startswith(p) for p in prefixes)
+    if head.startswith(NON_HUMAN_PREFIXES) or any(p and head.startswith(p) for p in prefixes):
+        return None
+    if head.startswith(COMMAND_PREFIXES):
+        name = COMMAND_NAME_RE.search(head)
+        if name and name.group(1).lower() in INERT_COMMANDS:
+            return "command"
+    return "user"
 
 
 def _verdict(cls, code, at, reset=None, rtype=""):
@@ -414,16 +555,23 @@ def _verdict(cls, code, at, reset=None, rtype=""):
 
 def classify_claude(rec, prefixes=(PROMPT_PREFIX,)):
     """One transcript record -> None | ("error", verdict) | ("never", code) |
-    ("cancel", why). No time filtering here — the tracker applies it."""
+    ("cancel", why), why = "user" | "command" (an inert slash command) | "assistant". No time
+    filtering here — the tracker applies it."""
     if not isinstance(rec, dict) or rec.get("isSidechain") is True:
         return None
     typ = rec.get("type")
     if typ == "user":
-        return ("cancel", "user") if claude_human_input(rec, prefixes) else None
+        human = claude_human_input(rec, prefixes)
+        return ("cancel", human) if human else None
     if typ != "assistant":
         return None  # system records ("continuing automatically at ...") never count
     if rec.get("isApiErrorMessage") is not True:
         return ("cancel", "assistant")  # a real reply: the user or auto-continue moved on
+    return claude_api_verdict(rec)
+
+
+def claude_api_verdict(rec):
+    """An API-error assistant record -> ("error", verdict) | ("never", code)."""
     code = rec.get("error") if isinstance(rec.get("error"), str) else ""
     at = iso_to_epoch(rec.get("timestamp"))
     if rec.get("apiError") == "model_requires_usage_credits":
@@ -435,6 +583,8 @@ def classify_claude(rec, prefixes=(PROMPT_PREFIX,)):
             if rtype in CLAUDE_QUOTA_TYPES:
                 return ("error", _verdict("quota", code, at, epoch_of(quota.get("resetsAt")),
                                           rtype))
+            if rtype in CLAUDE_THROTTLE_TYPES:
+                return ("error", _verdict("transient", code, at))
             # seven_day_opus, seven_day_overage_included, ...: one model's bucket.
             return ("error", _verdict("model", code, at))
         if MODEL_TEXT.search(_message_text(rec)):
@@ -452,26 +602,296 @@ def classify_claude(rec, prefixes=(PROMPT_PREFIX,)):
     return ("never", code or "?")
 
 
+def quota_lifted(verdict, now):
+    """A quota verdict whose reset has already passed: the limit it reports is gone, so
+    there is nothing to move the session away from (a watcher restarted onto old history,
+    a verdict that waited out its reset in a hold). Without a reset (resetsAt absent) the
+    verdict stands, as it always has."""
+    reset = verdict.get("reset") if verdict.get("class") == "quota" else None
+    return reset is not None and now is not None and reset <= now
+
+
+def keep_later_reset(into, other):
+    """Several rejections of one class are one verdict, marked with the LATEST reset any of
+    them named, and that reset's type: the account is out until every limit it met has
+    lifted (the five-hour one in one thread, the weekly one in another)."""
+    mine, theirs = into.get("reset"), other.get("reset")
+    if theirs is not None and (mine is None or theirs > mine):
+        into["reset"], into["rtype"] = theirs, other.get("rtype", "")
+
+
+def claude_served(rec):
+    """A real reply: an assistant record that is neither an API error nor the client's own
+    words (model "<synthetic>") — proof the account served when its request was sent
+    (claude_served_at)."""
+    if not isinstance(rec, dict) or rec.get("type") != "assistant" \
+            or rec.get("isApiErrorMessage") is True:
+        return False
+    msg = rec.get("message")
+    return not (isinstance(msg, dict) and msg.get("model") == "<synthetic>")
+
+
+# claude 2.1.300+ writes one of these right before each request it sends, main thread and
+# agents alike ({"type":"api-request", ..., "id": ..., "timestamp": ...}), and each reply to
+# that request names it by its "requestRef".
+API_REQUEST = b'{"type":"api-request"'
+REQUESTS_KEPT = 64  # per transcript: a reply's own request is one of its file's newest
+
+
+def note_request(rec, requests):
+    """Keep when an api-request record's request was sent: ``requests`` maps id -> epoch,
+    the REQUESTS_KEPT newest."""
+    rid, at = rec.get("id"), iso_to_epoch(rec.get("timestamp"))
+    if isinstance(rid, str) and at is not None:
+        requests[rid] = at
+        while len(requests) > REQUESTS_KEPT:
+            del requests[next(iter(requests))]
+
+
+def claude_served_at(rec, requests=None):
+    """When the account served a real reply: when its request was sent (its api-request
+    record in ``requests``, by the reply's requestRef), else the reply's own timestamp. A
+    reply is written as its stream ends, and one the account accepted before a limit can end
+    many minutes after it (up to 18 min in the transcripts of October 2026): that proves
+    nothing about the limit."""
+    at = iso_to_epoch(rec.get("timestamp"))
+    ref = rec.get("requestRef")
+    sent = requests.get(ref) if requests and isinstance(ref, str) else None
+    if sent is None:
+        return at
+    return sent if at is None else min(at, sent)
+
+
+def claude_answers(ev, rec):
+    """Whether a main-thread record (``ev``: classify_claude's) answers a rejection of the
+    ACCOUNT recorded before it: a real reply (the account served) or the user typing. An
+    inert slash command never does (the account is just as limited after /model), nor do the
+    client's own <synthetic> words."""
+    return ev == ("cancel", "user") or (ev == ("cancel", "assistant") and claude_served(rec))
+
+
+def classify_claude_sidechain(rec):
+    """One subagent or workflow transcript record -> None | ("error", verdict) |
+    ("cancel", "sidechain"). Untimed. A rejection of the ACCOUNT (ACCOUNT_CLASSES) is the
+    session's: the main thread would meet it on its next request, and the client, knowing
+    that, sends none — on 2026-10-19 two sessions sat idle behind paused workflows whose
+    agents alone had recorded the five-hour limit. A real reply (claude_served) proves the
+    account serves. A subagent's model-scoped or transient error is its own, and its user
+    records are its parent's prompts and tool results, never a human."""
+    if not isinstance(rec, dict) or rec.get("type") != "assistant":
+        return None
+    if rec.get("isApiErrorMessage") is not True:
+        return ("cancel", "sidechain") if claude_served(rec) else None
+    ev = claude_api_verdict(rec)
+    return ev if ev[0] == "error" and ev[1]["class"] in ACCOUNT_CLASSES else None
+
+
+# The agent id a detect line may name (the record's agentId, or the file's agent-<id>.jsonl).
+AGENT_RE = re.compile(r"^[A-Za-z0-9_-]{1,64}\Z")
+
+
+def sidechain_agent(rec, path):
+    """The agentId of a subagent transcript record (its file name's otherwise), for logs."""
+    agent = rec.get("agentId")
+    if isinstance(agent, str) and AGENT_RE.match(agent):
+        return agent
+    name = os.path.basename(path)[len("agent-"):-len(".jsonl")]
+    return name if AGENT_RE.match(name) else "-"
+
+
+def side_answer_at(rec, requests=None):
+    """When a subagent transcript record proved the account served (a real reply:
+    claude_served_at), or None."""
+    return claude_served_at(rec, requests) if claude_served(rec) else None
+
+
+# What every record that can answer a rejection holds as its "type": a reply (all a
+# subagent's transcript can answer with) and, in the main transcript, the user typing too.
+REPLY_MARKS = (b'"assistant"',)
+ANSWER_MARKS = (b'"assistant"', b'"user"')
+
+
+def newest_answer(lines, answer_at, marks=REPLY_MARKS):
+    """(moment, record) of the latest answer among ``lines`` (raw JSONL, in time order), or
+    None; ``answer_at`` maps a parsed record to the moment it answered the account, or None.
+    Scanned from the end, and only a line holding one of the byte ``marks`` is parsed: the
+    newest answer is found within a line or two as a rule, and never costs more than parsing
+    the read (in the main transcripts of 2026-10-19, at most 193 lines and 2.7 MB in a row
+    held a mark and answered nothing: tool results, request blobs). A reply answers from when
+    its request was sent, before records written after it, so the scan goes on to the first
+    record written no later than the best moment found: everything before it is older."""
+    best = None
+    for raw in reversed(lines):
+        if not any(mark in raw for mark in marks):
+            continue
+        rec = read_json_line(raw)
+        written = iso_to_epoch(rec.get("timestamp")) if rec is not None else None
+        if written is None:
+            continue
+        if best is not None and written <= best[0]:
+            break
+        at = answer_at(rec)
+        if at is not None and (best is None or at > best[0]):
+            best = (at, rec)
+    return best
+
+
+# The client's own words when the user stops a reply (Esc), mid-stream or in a tool.
+INTERRUPTED = "[Request interrupted by user"
+
+
+def main_thread_busy(lines):
+    """What a claude session's MAIN thread is in the middle of, from its transcript's newest
+    complete lines (raw JSONL, in order): "request" (its newest request has had nothing back),
+    "stream" (that request's reply is still streaming), "tool" (a tool the reply started has
+    no result yet), or None: idle (the reply finished, failed or was interrupted) or nothing
+    tells (no request on record: an older client).
+
+    Keyed by request, never by the order of the file: the client writes an api-request record
+    as it sends (sometimes before the prompt that led to it, and before the previous reply's
+    last blocks and tool results), and a reply a record per content block, each naming its
+    request (requestRef). A block written mid-stream carries "stop_reason": null; the last one
+    says why the reply stopped ("tool_use" can come blocks before its tool_use block), and the
+    reply's tools run after it. A block without the key (no client of this era writes one)
+    counts as finished: unknown is no reason to wait."""
+    lines = list(lines)
+    start = rid = None
+    for at in range(len(lines) - 1, -1, -1):
+        if not lines[at].startswith(API_REQUEST):
+            continue
+        rec = read_json_line(lines[at])
+        if rec is None or rec.get("isSidechain") is True or rec.get("agentId") \
+                or rec.get("querySource", "repl_main_thread") != "repl_main_thread":
+            continue
+        start, rid = at, rec.get("id")
+        break
+    if start is None or not isinstance(rid, str):
+        return None
+    blocks, results, stop = [], set(), ""
+    for raw in lines[start + 1:]:
+        if b'"assistant"' not in raw and b'"user"' not in raw:
+            continue
+        rec = read_json_line(raw)
+        if rec is None or rec.get("isSidechain") is True:
+            continue
+        msg = rec.get("message") if isinstance(rec.get("message"), dict) else {}
+        content = msg.get("content") if isinstance(msg.get("content"), list) else []
+        if rec.get("type") == "assistant":
+            if rec.get("isApiErrorMessage") is True:
+                return None  # the request failed
+            if rec.get("requestRef") == rid:
+                blocks.append(content)
+                stop = msg.get("stop_reason", "")
+        elif rec.get("type") == "user":
+            results.update(b.get("tool_use_id") for b in content
+                           if isinstance(b, dict) and b.get("type") == "tool_result")
+            if _message_text(rec).lstrip().startswith(INTERRUPTED):
+                return None  # the user stopped it
+    if not blocks:
+        return "request"
+    tools = [b.get("id") for content in blocks for b in content
+             if isinstance(b, dict) and b.get("type") == "tool_use"]
+    if any(tid not in results for tid in tools):
+        return "tool"
+    if stop is None or (stop == "tool_use" and not tools):
+        return "stream"
+    return None
+
+
 class ClaudeTracker:
-    """Folds a claude transcript's records into at most one pending verdict."""
+    """Folds a claude transcript's records into at most one pending verdict: the main
+    thread's own (feed), else an account-level one a subagent transcript recorded
+    (feed_side) — the main thread's verdict stands over a subagent's, except that an account
+    verdict (ACCOUNT_CLASSES) outranks a model or transient one, whichever thread met it:
+    the account serves the main thread no better, and a model/transient verdict waits on
+    busy agents (Watcher.decide) that are only being refused by then — on 2026-10-20 a
+    session sat six minutes behind its main thread's "concurrents" rejection while its agents
+    met the five-hour limit. The main thread's verdict it outranks waits as the fallback, and
+    stands once that one is gone (promote)."""
 
     def __init__(self, since, prefixes=(PROMPT_PREFIX,)):
         self.since = since
         self.prefixes = prefixes
         self.pending = None
         self.pending_since = None
+        # The newest moment since the launch at which something answered a subagent's
+        # rejection (the user typing, a real reply anywhere — from when its request was
+        # sent). Transcripts are read side by side, not in time order: a rejection older
+        # than that is answered already.
+        self.cleared = 0.0
+        self.requests = {}  # the main transcript's requests (note_request)
+        # The main thread's model or transient verdict while an account verdict outranks it:
+        # only the main thread itself ends that one, never an agent's reply.
+        self.fallback = None
 
     def clear(self):
         self.pending = None
         self.pending_since = None
 
+    def reset(self):
+        """Another conversation: nothing pending, and nothing the old one answered."""
+        self.clear()
+        self.fallback = None
+        self.cleared = 0.0
+        self.requests = {}
+
+    def promote(self, now):
+        """The account verdict is gone (an agent's was answered, a quota one's reset passed):
+        the main thread's model/transient verdict it outranked stands in its place. Whatever
+        the main thread did since has dropped that one already (feed). Returns the verdict
+        that stands, or None."""
+        fb, self.fallback = self.fallback, None
+        if fb is not None:
+            self.pending, self.pending_since = fb, now
+        return fb
+
+    def expire(self, now):
+        """A pending quota verdict whose reset passed while it waited (the grace, a hold
+        for want of room) is dropped instead of acted on. (dropped, the fallback that
+        stands in its place or None)."""
+        if self.pending is None or not quota_lifted(self.pending, now):
+            return False, None
+        self.clear()
+        return True, self.promote(now)
+
     def wants(self, raw):
         """Cheap byte prefilter: with nothing pending only an API error can matter (a
         cancel needs something to cancel), so a resumed 100 MB transcript is scanned for
-        one substring instead of parsed line by line."""
-        return self.pending is not None or b'"isApiErrorMessage"' in raw
+        one substring instead of parsed line by line. Each request record is read too (it
+        dates the replies to that request), and what the prefilter passes over still dates
+        the main thread's last answer (passed_over)."""
+        return self.pending is not None or b'"isApiErrorMessage"' in raw \
+            or raw.startswith(API_REQUEST)
+
+    def answered(self, stamp):
+        """Something answered the account at ``stamp`` (answer_at, side_answer_at)."""
+        if stamp is not None and stamp >= self.since:
+            self.cleared = max(self.cleared, stamp)
+
+    def answer_at(self, ev, rec):
+        """When a main-thread record (``ev``: classify_claude's) answered the account
+        (claude_answers): the user typing, at its timestamp; a real reply, when its request
+        was sent (claude_served_at). None for anything else, and for an undated answer."""
+        if not claude_answers(ev, rec):
+            return None
+        if ev[1] == "assistant":
+            return claude_served_at(rec, self.requests)
+        return iso_to_epoch(rec.get("timestamp"))
+
+    def passed_over(self, lines):
+        """The main-thread lines ``wants`` skipped: nothing was pending, so they cancel
+        nothing, but their latest answer still counts against a subagent's rejection older
+        than it, read now or later. Without it a watcher restarted onto hours of history
+        would act on a workflow agent's old limit in a session served ever since."""
+        found = newest_answer(lines, lambda r: self.answer_at(classify_claude(r, self.prefixes), r),
+                              ANSWER_MARKS)
+        if found is not None:
+            self.answered(found[0])
 
     def feed(self, rec, now):
+        if isinstance(rec, dict) and rec.get("type") == "api-request":
+            note_request(rec, self.requests)
+            return None
         ev = classify_claude(rec, self.prefixes)
         if ev is None:
             return None
@@ -479,8 +899,26 @@ class ClaudeTracker:
         stamp = iso_to_epoch(rec.get("timestamp"))
         if kind == "cancel":
             # A cancel only ever stops an action, so one without a timestamp still counts.
-            if self.pending is None or (stamp is not None and stamp < self.since):
+            if stamp is not None and stamp < self.since:
+                return None
+            answer = claude_answers(ev, rec)
+            at = self.answer_at(ev, rec)
+            if answer:
+                self.answered(at)
+            # Whatever the main thread does next ends its own model/transient verdict, the
+            # one waiting behind an account verdict too: /model handled it, or it moved on.
+            self.fallback = None
+            pending = self.pending
+            if pending is None:
                 return None
+            if pending.get("src") == "sidechain":
+                # Only an answer ends a subagent's verdict, and only one given after it (a
+                # reply from when its request was sent): the main thread's older last word
+                # answers nothing (read late, it still says so).
+                if not answer or (at is not None and at <= pending["at"]):
+                    return None
+            elif val == "command" and pending["class"] in ACCOUNT_CLASSES:
+                return None  # /model handles a model's limit or a failed turn, never these
             self.clear()
             return ev
         # An error must PROVE it is from this launch: a resumed transcript carries every
@@ -489,11 +927,70 @@ class ClaudeTracker:
             return None
         if kind == "never":
             return ev
-        if self.pending is None or self.pending["class"] != val["class"]:
+        if quota_lifted(val, now):
+            return None  # its limit has reset already: nothing to move away from
+        pending = self.pending
+        if pending is not None and pending["class"] in ACCOUNT_CLASSES \
+                and val["class"] not in ACCOUNT_CLASSES:
+            # The account's verdict outranks this one, which waits behind it as the main
+            # thread's newest word, should an agent's verdict be answered or a reset pass.
+            self.fallback = val
+            return None
+        self.fallback = None  # the main thread met something newer: what it met before is moot
+        if pending is not None and pending["class"] == val["class"]:
+            keep_later_reset(val, pending)
+        else:
             self.pending_since = now
         self.pending = val
         return ev
 
+    def feed_side(self, rec, now, agent="-", requests=None):
+        """One subagent or workflow transcript record (classify_claude_sidechain;
+        ``requests``: that transcript's, note_request). Its rejection must come from this
+        launch's own agents (SIDE_AFTER), be newer than anything that answered it, and name a
+        limit that has not reset yet. It outranks the main thread's model/transient verdict,
+        which then waits behind it (promote); a main-thread account verdict stands (taking
+        this one's later reset when it is of the same class), as does a newer subagent one.
+        Only a reply to a request sent after a subagent's verdict cancels it there."""
+        ev = classify_claude_sidechain(rec)
+        if ev is None:
+            return None
+        kind, val = ev
+        stamp = iso_to_epoch(rec.get("timestamp"))
+        if stamp is None or stamp < self.since:
+            return None
+        pending = self.pending
+        if kind == "cancel":
+            at = claude_served_at(rec, requests)
+            self.answered(at)
+            if pending is None or pending.get("src") != "sidechain" or at <= pending["at"]:
+                return None
+            self.clear()
+            # the main thread's own verdict behind it stands again: an agent's reply answers
+            # the account, never the main thread's model limit or its failed turn
+            promoted = self.promote(now)
+            return ("error", promoted) if promoted is not None else ev
+        if stamp < self.since + SIDE_AFTER or stamp < self.cleared or quota_lifted(val, now):
+            return None
+        val.update(src="sidechain", agent=agent)
+        if pending is not None and pending["class"] not in ACCOUNT_CLASSES:
+            self.fallback = pending  # the main thread's model/transient verdict: outranked
+            self.pending, self.pending_since = val, now
+            return ev
+        if pending is not None and pending.get("src") != "sidechain":
+            if pending["class"] == val["class"]:
+                keep_later_reset(pending, val)
+            return None
+        if pending is not None and pending["class"] == val["class"]:
+            # another agent met the same limit: it still stands, until the later reset
+            keep_later_reset(pending, val)
+            pending["at"] = max(pending["at"], stamp)
+            return None
+        if pending is not None and stamp < pending["at"]:
+            return None  # an older verdict read late never replaces a newer one
+        self.pending, self.pending_since = val, now
+        return ev
+
 
 # ---- codex classification -----------------------------------------------------------
 
@@ -709,6 +1206,13 @@ def claude_argv_parse(argv):
     return kept
 
 
+def codex_effort_ok(val):
+    """``model_reasoning_effort=<level>``: the one ``-c`` override a relaunch carries (it pins
+    the session's effort); every other config override stays outside the allowlist."""
+    return isinstance(val, str) and val.startswith(CODEX_EFFORT_KEY) \
+        and EFFORT_VALUE_RE.match(val[len(CODEX_EFFORT_KEY):]) is not None
+
+
 def codex_argv_parse(argv):
     """The argv shapes a codex relaunch can rebuild (mirrors bin/codex's ar_argv_ok) ->
     (kept options, resume target or None), or None for anything else."""
@@ -725,8 +1229,9 @@ def codex_argv_parse(argv):
             conservative.add(arg)
             kept += [arg, expected]
             i += 1
-        elif arg in ("-m", "--model"):
-            if i + 1 >= len(argv) or not _value_ok(argv[i + 1]):
+        elif arg in ("-m", "--model", "-c"):
+            value_ok = codex_effort_ok if arg == "-c" else _value_ok
+            if i + 1 >= len(argv) or not value_ok(argv[i + 1]):
                 return None
             kept += [arg, argv[i + 1]]
             i += 1
@@ -777,11 +1282,16 @@ def prompt_override_ok(text):
             and " " in text and not any(c in text for c in "\0\n\r"))
 
 
-def resume_prompt(cls, override=None):
+def resume_prompt(cls, override=None, detail=None):
+    """The relaunch's prompt for a verdict of class ``cls``; ``detail`` (a memory verdict's
+    size) follows the reason in parentheses. The classes that may continue on the same
+    account never claim another one."""
     reason = REASONS[cls]
+    if detail:
+        reason += " (%s)" % detail
     if override and prompt_override_ok(override):
         return override.replace("{reason}", reason)
-    where = "" if cls in ("crash", "transient") else " on another account"
+    where = "" if cls in ("crash", "transient", "memory") else " on another account"
     return PROMPT_TEMPLATE.format(where=where, reason=reason)
 
 
@@ -792,28 +1302,114 @@ def prompt_prefixes(override=None):
     return tuple(out)
 
 
-def relaunch_argv(provider, argv, sid, cls, prompt=None):
-    """The argv the relaunched shim runs, built from the ORIGINAL argv.
+def history_model(settings):
+    """The model ``settings`` names, when it is a value a relaunch can carry; else None."""
+    model = settings.get("model") if isinstance(settings, dict) else None
+    return model if isinstance(model, str) and MODEL_VALUE_RE.match(model) else None
+
+
+def settings_argv(provider, settings):
+    """The flags that pin ``settings`` ({"model", "effort"}, what the session itself last ran
+    with) for ``provider``: model_match.settings_flags over the values a relaunch can carry
+    (anything else counts as unknown). [] when nothing is known."""
+    effort = settings.get("effort") if isinstance(settings, dict) else None
+    effort = effort if isinstance(effort, str) and EFFORT_VALUE_RE.match(effort) else None
+    return settings_flags(provider, history_model(settings), effort)
+
+
+def argv_settings(provider, argv):
+    """{"model": M, "effort": E} that an argv pins, only the ones it names (the last of each
+    wins, as in the CLIs): what a switch line reports the relaunched client was given."""
+    found, i = {}, 0
+    model_opts = ("--model",) if provider == "claude" else ("-m", "--model")
+    while i < len(argv):
+        arg, val = argv[i], (argv[i + 1] if i + 1 < len(argv) else "")
+        if arg.startswith("--model=") and len(arg) > len("--model="):
+            found["model"] = arg[len("--model="):]
+        elif arg in model_opts and _value_ok(val):
+            found["model"] = val
+            i += 1
+        elif provider == "claude" and arg == "--effort" and _value_ok(val):
+            found["effort"] = val
+            i += 1
+        elif provider == "codex" and arg == "-c" and codex_effort_ok(val):
+            found["effort"] = val[len(CODEX_EFFORT_KEY):]
+            i += 1
+        i += 1
+    return found
+
+
+def claude_model_left(launch, served):
+    """Whether a Claude session launched with ``--model <launch>`` has since run on another
+    model (``served``: its history's last). A full id compares without its context suffix, a
+    family alias by family; any other alias (best, opusplan, default), and a served model this
+    cannot read, counts as kept."""
+    if not (isinstance(launch, str) and isinstance(served, str) and MODEL_VALUE_RE.match(served)):
+        return False
+    launch, served = CONTEXT_SUFFIX_RE.sub("", launch), CONTEXT_SUFFIX_RE.sub("", served)
+    if launch.startswith("claude-"):
+        ids = parse_id("claude", launch), parse_id("claude", served)  # a dated id names the same model
+        return ids[0] != ids[1] if ids[0][0] and ids[1][0] else launch != served
+    family = parse_id("claude", served)[0] if launch in CLAUDE_FAMILY_ALIASES else None
+    return family is not None and family != launch
+
+
+def without_settings(kept, model, effort):
+    """``kept`` without its model options (-m V, --model V, --model=V) when ``model`` and its
+    effort options (--effort V, codex's -c model_reasoning_effort=V) when ``effort``. Both
+    parsers refuse a value that starts with "-", so no value is ever taken for an option."""
+    out, i = [], 0
+    while i < len(kept):
+        arg = kept[i]
+        if (model and arg in ("-m", "--model")) or (effort and arg in ("--effort", "-c")):
+            i += 2
+            continue
+        if not (model and arg.startswith("--model=")):
+            out.append(arg)
+        i += 1
+    return out
 
-    claude: the kept options + ``--resume <sid> <prompt>`` — no --model added: Claude
-    restores the session's own model on --resume ([1m] included), and an explicit
-    --model would switch that restore off.
+
+def relaunch_argv(provider, argv, sid, cls, prompt=None, settings=None, detail=None):
+    """The argv the relaunched shim runs, built from the ORIGINAL argv (``detail``: what the
+    prompt adds to the reason, resume_prompt).
+
+    claude: the kept options + ``--resume <sid> <prompt>``.
     codex: ``resume <kept options> <sid> <prompt>``.
+    ``settings`` ({"model", "effort"}, read from the session's own history) pins what the
+    session last ran with, a /model or /effort since the launch included: the flags go right
+    before the session id (claude: before --resume) and replace the launch's own options.
+    Codex drops the thread's other saved value on a model or an effort flag alone, so it gets
+    both or neither (model_match.settings_flags), and when the history names the model but no
+    effort to pin with it, the launch's own model/effort options go too: Codex then restores
+    both from the thread's shared state. Claude gets the effort alone (--resume never restores
+    it): an explicit --model turns off --resume's own model restore and puts bin/claude in
+    explicit-model mode, where its model-scoped fallback no longer applies -- so the launch's
+    --model is replayed, and dropped only once the history shows the session left it. Without
+    settings the launch's options are replayed as given.
     None when the argv is outside the allowlist or the id is not a session id."""
     if not uuid_ok(sid) or cls not in REASONS:
         return None
-    text = resume_prompt(cls, prompt)
+    text = resume_prompt(cls, prompt, detail)
     if provider == "claude":
-        kept = claude_argv_parse(argv)
-        if kept is None:
-            return None
-        return kept + ["--resume", sid, text]
-    if provider == "codex":
+        kept, head, tail = claude_argv_parse(argv), [], ["--resume", sid, text]
+    elif provider == "codex":
         parsed = codex_argv_parse(argv)
-        if parsed is None:
-            return None
-        return ["resume"] + parsed[0] + [sid, text]
-    return None
+        kept, head, tail = (None if parsed is None else parsed[0]), ["resume"], [sid, text]
+    else:
+        return None
+    if kept is None:
+        return None
+    settings = settings if isinstance(settings, dict) else {}
+    left = False
+    if provider == "claude":
+        left = claude_model_left(argv_settings("claude", kept).get("model"), settings.get("model"))
+        settings = {"effort": settings.get("effort")}
+    flags = settings_argv(provider, settings)
+    model, effort = left or "--model" in flags or "-m" in flags, "--effort" in flags or "-c" in flags
+    if provider == "codex" and not flags and history_model(settings):
+        model = effort = True  # no launch -m or -c alone: neither, and the thread restores both
+    return head + without_settings(kept, model, effort) + flags + tail
 
 
 # ---- relaunch / state files ---------------------------------------------------------
@@ -962,6 +1558,8 @@ def load_state(path):
         "rollout_cursor": kv.get("rollout_cursor", ""),
         **{key: kv.get(key, "") for key in ("avoid_claude", "avoid_codex", "pool_claude",
                                           "pool_codex", "handoff_token")},
+        # claude: the credential the shim launched the run on (bin/claude ar_start_watcher)
+        "via": kv.get("via") if kv.get("via") in ("token", "login") else "",
     }
 
 
@@ -1122,6 +1720,104 @@ def notice_argv(sock, pane, provider, sid, sticky=True):
                     "claude-multiacc: auto-resume failed — run: " + resume_hint(provider, sid))
 
 
+def capture_argv(sock, pane):
+    """The pane's screen as text (-p), its wrapped rows joined (-J). Read-only: the memory
+    watch's one look at the pane, never a key."""
+    return tmux_cmd(sock, "capture-pane", "-p", "-J", "-t", pane)
+
+
+def screen_rows(text):
+    """A captured screen's rows as plain text: escape sequences and controls dropped, trailing
+    spaces and blank bottom rows gone. The client's no-break spaces stay: one marks the
+    prompt's row (PROMPT_ROW_RE), the last character of an empty prompt."""
+    rows = [CONTROL_RE.sub("", ANSI_RE.sub("", row)).rstrip(" \t")
+            for row in (text or "").split("\n")]
+    while rows and not rows[-1].strip():
+        rows.pop()
+    return rows
+
+
+def prompt_box(rows):
+    """(top, bottom): the rows of the two rules of the prompt's box (RULE_RE, PROMPT_ROW_RE)
+    among ``rows``, or None. The box is the last prompt row on screen with a rule right above
+    it, closed by the first rule after it within PROMPT_ROWS rows. Rows the box holds are
+    indented past the mode indicator, so none of them reads as either."""
+    for at in range(len(rows) - 1, 0, -1):
+        if PROMPT_ROW_RE.match(rows[at]) and RULE_RE.match(rows[at - 1]):
+            for end in range(at + 1, min(len(rows), at + 1 + PROMPT_ROWS)):
+                if RULE_RE.match(rows[end]):
+                    return at - 1, end
+            return None
+    return None
+
+
+def banner_size(row):
+    """The size in the client's critical-memory banner on one row, or None: MEMORY_BANNER_RE,
+    then MEMORY_TAIL -- whole, with or without its optional end, or a start of it and the
+    ellipsis it was cut at -- and after that nothing to the row's end but the client's own
+    pills (MEMORY_AFTER_RE). Words after the banner or after its ellipsis are not the
+    client's, and neither is a hyphen or an en dash after the size."""
+    for found in MEMORY_BANNER_RE.finditer(row):
+        rest = row[found.end():]
+        cut = rest.find("…")
+        if 0 <= cut < len(MEMORY_TAIL) and MEMORY_TAIL.startswith(rest[:cut]):
+            after = rest[cut + 1:]
+        elif rest.startswith(MEMORY_TAIL):
+            after = rest[len(MEMORY_TAIL):]
+        elif rest.startswith(MEMORY_TAIL[:MEMORY_TAIL_MIN]):
+            after = rest[MEMORY_TAIL_MIN:]
+        else:
+            continue
+        if MEMORY_AFTER_RE.fullmatch(after):
+            return found.group(1)
+    return None
+
+
+def memory_banner(text):
+    """The size the client's critical-memory banner names on a captured screen, or None. Only
+    the client's own status counts: the footer of the prompt's box (prompt_box), the rows
+    under its bottom rule down to the first blank row. The conversation is above the box and
+    the draft inside it, so the banner's words in a reply, a quoted log line, a tool's output
+    or the prompt never count, and neither do the background tasks below the footer -- nor a
+    task's row under its first row (TASK_ROW_RE), blank row or none. A screen with no prompt
+    box (a dialog in its place, the transcript view, a picker) has no banner."""
+    rows = screen_rows(text)
+    box = prompt_box(rows)
+    if box is None:
+        return None
+    for at, row in enumerate(rows[box[1] + 1:]):
+        if not row.strip():
+            break
+        if at and TASK_ROW_RE.match(row):
+            continue
+        size = banner_size(row)
+        if size:
+            return size
+    return None
+
+
+def compacting(text):
+    """Whether a captured screen shows the client compacting its conversation: COMPACTING in
+    one of the MEMORY_ROWS rows above the prompt's box (its spinner, the todo list between it
+    and the box). Read generously -- the conversation's own words can match -- as all a reading
+    does is make a memory verdict wait for the compaction to end, MEMORY_BUSY_CAP at most."""
+    rows = screen_rows(text)
+    box = prompt_box(rows)
+    return box is not None and any(COMPACTING in row
+                                   for row in rows[max(0, box[0] - MEMORY_ROWS):box[0]])
+
+
+def format_size(nbytes):
+    """Bytes the way the client prints its heap (8.3GB, 512MB): one decimal, ".0" dropped."""
+    val, unit = nbytes / 1024.0, "KB"
+    for bigger in ("MB", "GB"):
+        if val < 1024:
+            break
+        val, unit = val / 1024.0, bigger
+    text = "%.1f" % val
+    return (text[:-2] if text.endswith(".0") else text) + unit
+
+
 # ---- side effects -------------------------------------------------------------------
 
 def descendants(table, pid):
@@ -1268,6 +1964,36 @@ class Runner:
             return None
         return [line[1:] for line in out.split("\n") if line.startswith("n")]
 
+    def footprint(self, pid):
+        """The memory ``pid`` holds, in bytes, or None when it cannot be read. Linux: VmRSS +
+        VmSwap. macOS: its phys_footprint (what Activity Monitor calls Memory), from libproc's
+        proc_pid_rusage -- rusage_info_v0 is the uuid then ten uint64s, the footprint the
+        eighth -- for a process of this user. Read-only, no child process."""
+        if os.path.isdir("/proc/self"):
+            found = {}
+            try:
+                with open("/proc/%d/status" % pid) as fh:
+                    for line in fh:
+                        key, _, rest = line.partition(":")
+                        if key in ("VmRSS", "VmSwap"):
+                            found[key] = int(rest.split()[0]) * 1024
+            except (OSError, ValueError, IndexError):
+                return None
+            return sum(found.values()) if "VmRSS" in found else None
+        if sys.platform != "darwin":
+            return None
+        try:
+            import ctypes
+            call = ctypes.CDLL("/usr/lib/libproc.dylib").proc_pid_rusage
+            call.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_void_p]
+            call.restype = ctypes.c_int
+            buf = ctypes.create_string_buffer(256)
+            if call(pid, 0, buf) != 0:  # RUSAGE_INFO_V0
+                return None
+            return struct.unpack_from("=Q", buf.raw, 16 + 7 * 8)[0]
+        except (ImportError, OSError, AttributeError, ValueError, struct.error):
+            return None
+
 
 # ---- transcript / rollout tailing ---------------------------------------------------
 
@@ -1285,8 +2011,13 @@ class JsonlTail:
         self.buf = b""
         self.skip = False
         self.ino = None
+        self.got = 0       # bytes the last read took
+        self.behind = 0    # bytes the file held beyond them
+        self.requests = {}  # claude subagent transcripts: their requests (note_request)
 
-    def read_lines(self):
+    def read_lines(self, limit=None):
+        """``limit`` caps the bytes this read takes (MAX_READ at most)."""
+        self.got = self.behind = 0
         try:
             fh = open(self.path, "rb")
         except OSError:
@@ -1302,8 +2033,9 @@ class JsonlTail:
             if st.st_size == self.off:
                 return []
             fh.seek(self.off)
-            data = fh.read(self.MAX_READ)
+            data = fh.read(self.MAX_READ if limit is None else max(1, min(limit, self.MAX_READ)))
         self.off += len(data)
+        self.got, self.behind = len(data), max(0, st.st_size - self.off)
         if self.skip:
             cut = data.find(b"\n")
             if cut < 0:
@@ -1391,6 +2123,19 @@ class Quoted(str):
     """A log value written as ``key="value"`` with its spaces kept (the resume command)."""
 
 
+class Pacing:
+    """What decide() keeps while it acts on one verdict: when it last probed for room (again
+    HOLD_REPROBE s later at the soonest), and whether its hold and its wait for the main
+    thread are logged (once each). The transcript's verdict and the memory verdict have one
+    each, so neither one's coming and going re-probes or re-logs the other."""
+
+    __slots__ = ("probed", "held", "waited")
+
+    def __init__(self):
+        self.probed = None
+        self.held = self.waited = False
+
+
 class Watcher:
     """One supervised session: tail, classify, decide, stop, relaunch — or just exit."""
 
@@ -1417,21 +2162,41 @@ class Watcher:
         self.cwd = None
         self.tail = None
         self.transcript = None
+        self.side = {}         # claude: subagent/workflow transcript path -> JsonlTail
+        self.side_order = []   # the ones followed, the most recently written first
+        self.side_behind = False  # the last read of them left lines unread
+        self.next_side = 0.0
+        self.recent = deque()  # claude: the main transcript's newest lines (MAIN_RECENT_BYTES)
+        self.recent_bytes = 0
+        self.busy_memo = None  # (lines read so far, main_thread_busy of them)
+        self.lines_read = 0
         self.lstart = None
         self.started = None
         self.next_find = 0.0
         self.next_lsof = 0.0
         self.next_fallback = 0.0
         self.never_seen = set()
-        self.hold_logged = False
-        self.last_probe = None
+        self.pace = Pacing()   # the transcript's verdict's probe and logs (rearm)
         self.cross_plan = None
+        self.served_model = None  # the model this session's history last names (relaunch_settings)
         self.claim = os.path.join(self.stdir, "%d.rollout" % self.pid)
         self.root = None       # the pool, when the relaunch has to name it
         self.stopped = False   # True once this watcher has signalled the client
         self.tree = []         # [(pid, lstart)] of the client's descendants at the stop
         self._open_files_ok = None
         self.lookup_failed_at = None
+        # claude: the client's critical-memory banner (watch_memory). A verdict of its own,
+        # beside the tracker's: it waits behind any transcript verdict, and only the banner
+        # going away ends it.
+        self.memory = None
+        self.memory_since = None
+        self.memory_pace = Pacing()  # its own: the transcript's verdict never shares it
+        self.next_memory = 0.0
+        self.memory_off = False  # this process's memory relaunches are over (memory-budget)
+        # What the memory verdict waits for, each since it was first seen (memory_waits): the
+        # main thread's work in flight, and a compaction the pane shows under way.
+        self.memory_busy_since = None
+        self.memory_compact_since = None
 
     # -- logging --
 
@@ -1497,7 +2262,8 @@ class Watcher:
                 if not self.r.alive(self.pid):
                     return self.on_exit()
                 self.read()
-                if self.tracker.pending is not None:
+                self.watch_memory()
+                if self.tracker.pending is not None or self.memory is not None:
                     rc = self.decide()
                     if rc is not None:
                         return rc
@@ -1568,8 +2334,11 @@ class Watcher:
                     # included, which is not this client's and not this account's.
                     # Only what is written from now on is ours.
                     self.tracker.since = max(self.tracker.since, now - 2)
-                self.tracker.clear()
+                self.tracker.reset()
                 self.sid, self.tail, self.transcript = sid, None, None
+                self.side, self.side_order, self.side_behind, self.next_side = {}, [], False, 0.0
+                self.recent.clear()
+                self.recent_bytes, self.busy_memo = 0, None
             if cwd:
                 self.cwd = cwd
         if self.sid and self.tail is None and now >= self.next_find:
@@ -1581,7 +2350,91 @@ class Watcher:
                 self.tail = JsonlTail(found[0])
                 self.dbg("transcript %s" % found[0])
         if self.tail is not None:
-            self.pump()
+            # The main thread's own record first, and the newest answer among what the
+            # prefilter skipped with it; the subagents' is read once the main transcript is
+            # caught up (a resumed one can take several reads).
+            self.tracker.passed_over(self.pump())
+            if self.tail.behind == 0:
+                self.read_sidechains()
+
+    def read_sidechains(self):
+        """This session's subagent and workflow transcripts, for what they can say about
+        the ACCOUNT (classify_claude_sidechain). Only API-error and request lines are parsed,
+        plus each read's latest reply (newest_answer), which dates the account's last
+        service in it from when that reply's request was sent; the replies go first, so a
+        rejection they answer never shows as pending."""
+        now = self.r.now()
+        if now >= self.next_side:
+            self.next_side = now + self.cfg.subagent_scan
+            self.find_sidechains()
+        budget, replies, errors, behind = SIDE_BYTES, [], [], False
+        for path in self.side_order:
+            if budget <= 0:
+                behind = True
+                break
+            tail = self.side[path]
+            lines = tail.read_lines(budget)
+            budget -= tail.got
+            behind = behind or tail.behind > 0
+            for raw in lines:
+                if raw.startswith(API_REQUEST):
+                    rec = read_json_line(raw)
+                    if rec is not None:
+                        note_request(rec, tail.requests)
+            found = newest_answer(lines, lambda rec, sent=tail.requests: side_answer_at(
+                rec, sent)) if lines else None
+            if found is not None:
+                replies.append((found[1], path))
+            errors += [(raw, path) for raw in lines if b'"isApiErrorMessage"' in raw]
+        self.side_behind = behind
+        for rec, path in replies + [(read_json_line(raw), path) for raw, path in errors]:
+            if rec is None:
+                continue
+            before = self.tracker.pending
+            ev = self.tracker.feed_side(rec, now, sidechain_agent(rec, path),
+                                        self.side[path].requests)
+            if ev is not None:
+                self.on_event(ev, before)
+
+    def find_sidechains(self):
+        """agent-*.jsonl anywhere under projects/*/<sid>/subagents (subagents/ itself,
+        workflows/wf_*/), in a walk of at most SIDE_SCAN entries; never journal.jsonl or
+        *.meta.json. The SIDE_FILES written most recently are followed. One new to the
+        watcher starts at its end when it was last written before this launch, else at its
+        start (the tracker's time filter still applies). A file no longer followed keeps
+        its place for as long as it is there."""
+        found, budget = [], SIDE_SCAN
+        for base in sorted(glob.glob(os.path.join(self.acct_dir, "projects", "*", self.sid,
+                                                  "subagents"))):
+            for root, _dirs, files in os.walk(base):
+                for name in files[:budget]:
+                    if not (name.startswith("agent-") and name.endswith(".jsonl")):
+                        continue
+                    path = os.path.join(root, name)
+                    try:
+                        st = os.stat(path)
+                    except OSError:
+                        continue
+                    if stat.S_ISREG(st.st_mode):
+                        found.append((st.st_mtime, path, st))
+                budget -= min(len(files), budget)
+                if budget <= 0:
+                    break
+            if budget <= 0:
+                break
+        found.sort(key=lambda entry: (entry[0], entry[1]), reverse=True)
+        side = {}
+        for rank, (mtime, path, st) in enumerate(found):
+            tail = self.side.get(path)
+            if tail is None and rank < SIDE_FILES:
+                tail = JsonlTail(path)
+                if mtime < self.tracker.since - SIDE_SLACK:
+                    tail.off, tail.ino = st.st_size, st.st_ino
+                self.dbg("sidechain %s from %s" % (path, "its end" if tail.off else "the start"))
+            if tail is not None:
+                side[path] = tail
+        self.side = side
+        self.side_order = [path for _mtime, path, _st in found[:SIDE_FILES]]
 
     def read_codex(self):
         if self.tail is None and not self.discover():
@@ -1589,9 +2442,15 @@ class Watcher:
         self.pump()
 
     def pump(self):
+        """Feed what the transcript or rollout wrote since the last read; returns the lines
+        the tracker's prefilter passed over."""
         now = self.r.now()
+        passed = []
         for raw in self.tail.read_lines():
+            if self.provider == "claude":
+                self.remember(raw)
             if not self.tracker.wants(raw):
+                passed.append(raw)
                 continue
             rec = read_json_line(raw)
             if rec is None:
@@ -1600,6 +2459,23 @@ class Watcher:
             ev = self.tracker.feed(rec, now)
             if ev is not None:
                 self.on_event(ev, before)
+        return passed
+
+    def remember(self, raw):
+        """Keep a main-transcript line among the newest MAIN_RECENT_BYTES (the newest one
+        always), for main_busy: no second read of the file."""
+        self.recent.append(raw)
+        self.recent_bytes += len(raw)
+        self.lines_read += 1
+        while self.recent_bytes > MAIN_RECENT_BYTES and len(self.recent) > 1:
+            self.recent_bytes -= len(self.recent.popleft())
+
+    def rearm(self):
+        """Any change of the transcript's state re-arms the hold logs and probes immediately:
+        its verdict's, and the memory verdict's, which waits behind any of them. The memory
+        verdict's own coming and going re-arms only its own (memory_update)."""
+        self.pace = Pacing()
+        self.memory_pace = Pacing()
 
     def on_event(self, ev, before):
         kind, val = ev
@@ -1608,16 +2484,16 @@ class Watcher:
                 self.never_seen.add(val)
                 self.log("never", code=val, sid=self.sid, acct=self.acct)
             return
-        # Any change of state re-arms the hold log and probes immediately.
-        self.hold_logged = False
-        self.last_probe = None
+        self.rearm()
         if kind == "cancel":
             self.dbg("verdict cancelled by %s" % val)
             return
         if before is None or before["class"] != val["class"]:
-            self.log("detect", **{"class": val["class"], "code": val["code"],
-                                  "sid": self.sid, "acct": self.acct,
-                                  "reset": val.get("reset") or "-"})
+            fields = {"class": val["class"], "code": val["code"], "sid": self.sid,
+                      "acct": self.acct, "reset": val.get("reset") or "-"}
+            if val.get("src") == "sidechain":
+                fields.update(src="sidechain", agent=val.get("agent") or "-")
+            self.log("detect", **fields)
 
     # -- codex rollout discovery --
 
@@ -1714,6 +2590,83 @@ class Watcher:
                     return self.attach(cands[0], meta, "cwd-fallback")
         return False
 
+    # -- the client's critical-memory banner (claude) --
+
+    def client_in_front(self):
+        """The client runs in the foreground of its terminal and is not stopped (Ctrl-Z): the
+        pane shows its screen, and once it ends the prompt is the shell's. The suites'
+        no-terminal knob waives the foreground (a client without a terminal has none)."""
+        client = self.r.proc_status(self.pid)
+        flags = client[0] if client else ""
+        return bool(client) and "T" not in flags and not flags.startswith("t") \
+            and ("+" in flags or self.cfg.test_tty)
+
+    def watch_memory(self):
+        """Every MEMORY_SCAN s, once the launch is MEMORY_MIN_UPTIME old (a resumed session
+        can come back as heavy as it left, and must not be restarted in a loop), read whether
+        the client is at critical memory (memory_reading). A reading makes the memory verdict,
+        which decide() acts on like any other; one without ends it: /compact can bring the
+        heap back under the line, and the banner goes with it."""
+        if self.provider != "claude" or self.memory_off or self.cfg.memory_scan <= 0:
+            return
+        now = self.r.now()
+        if now < self.next_memory or now - self.launched < self.cfg.memory_min_uptime:
+            return
+        self.next_memory = now + self.cfg.memory_scan
+        self.memory_update(self.memory_reading(), now)
+
+    def memory_reading(self):
+        """(code, size, src) while the client is at critical memory, else None: its banner on
+        this pane (critical_memory, src=pane), else -- only with MEMORY_LIMIT_MB set -- its own
+        memory at that limit or over (memory_limit, src=process). Read only for a session a
+        relaunch can name, while the pane is still the launching shell's and the client runs
+        in front of it: capture-pane on the watcher's own socket and pane, never a key."""
+        if not self.sid or not self.transcript:
+            return None
+        sock = tmux_socket(self.st["tmux"])
+        if not sock or not self.pane_is_ours(self.pane_info(sock)) or not self.client_in_front():
+            return None
+        rc, out = self.r.run(capture_argv(sock, self.st["pane"]), 10)
+        screen = out if rc == 0 else ""
+        if rc == 0:
+            if not compacting(screen):
+                self.memory_compact_since = None
+            elif self.memory_compact_since is None:
+                self.memory_compact_since = self.r.now()
+        size = memory_banner(screen)
+        if size:
+            return "critical_memory", size, "pane"
+        if self.cfg.memory_limit_mb > 0:
+            used = self.r.footprint(self.pid)
+            if used is not None and used >= self.cfg.memory_limit_mb * (1 << 20):
+                return "memory_limit", format_size(used), "process"
+        return None
+
+    def memory_update(self, found, now):
+        """Fold a memory_reading into the memory verdict: a new one is logged (detect), one
+        that stands keeps its age and takes the newest size, and no reading ends it. Only the
+        memory verdict's own state changes: a banner that comes and goes (a heap near the line,
+        a pane read that timed out) never re-probes or re-logs a transcript verdict."""
+        if found is None:
+            if self.memory is not None:
+                self.dbg("memory verdict cleared: the client is not at critical memory now")
+                self.drop_memory()
+            return
+        code, size, src = found
+        if self.memory is not None:
+            self.memory.update(code=code, size=size, src=src)
+            return
+        self.memory = dict(_verdict("memory", code, now), size=size, src=src)
+        self.memory_since, self.memory_busy_since = now, None
+        self.memory_pace = Pacing()
+        self.log("detect", **{"class": "memory", "code": code, "sid": self.sid,
+                              "acct": self.acct, "reset": "-", "size": size, "src": src})
+
+    def drop_memory(self):
+        """No memory verdict any more, and nothing it waited for or logged."""
+        self.memory = self.memory_since = self.memory_busy_since = None
+        self.memory_pace = Pacing()
+
     # -- deciding --
 
     def subagents_busy(self, now):
@@ -1735,6 +2688,15 @@ class Watcher:
                     return newest > 0 and now - newest < self.cfg.subagent_quiet
         return newest > 0 and now - newest < self.cfg.subagent_quiet
 
+    def main_busy(self):
+        """What the main thread is in the middle of (main_thread_busy), or None: from the
+        lines read so far, so only once they change."""
+        if self.provider != "claude":
+            return None
+        if self.busy_memo is None or self.busy_memo[0] != self.lines_read:
+            self.busy_memo = (self.lines_read, main_thread_busy(self.recent))
+        return self.busy_memo[1]
+
     def session_cwd(self):
         """Where the probe and the relaunch run. claude: the registry's cwd first
         (``--resume`` finds the transcript by it). codex: the launch directory first, so
@@ -1746,39 +2708,145 @@ class Watcher:
                 return cand
         return None
 
-    def build_relaunch_argv(self, cls):
-        return relaunch_argv(self.provider, self.argv, self.sid, cls, self.cfg.prompt)
+    def build_relaunch_argv(self, cls, detail=None):
+        """The relaunch argv, pinned to the model and effort the session last ran with."""
+        return relaunch_argv(self.provider, self.argv, self.sid, cls, self.cfg.prompt,
+                             self.relaunch_settings(), detail)
+
+    def relaunch_settings(self):
+        """{"model", "effort"} the relaunch pins: this session's own, read from its history at
+        decide time (a /model or /effort since the launch counts), or None. Fail-open: a
+        session whose settings cannot be read relaunches exactly as it always has."""
+        try:
+            found = session_settings(self.provider, self.transcript)
+            self.served_model = history_model(found)
+            if not found.get("model") and not found.get("effort"):
+                return None
+            # The catalog only clamps an effort to the model and supplies Codex's default
+            # one: this pool's copy and caches, the other pool's only when the chain named it.
+            roots = {self.provider: self.st["acc_root"]}
+            other = "codex" if self.provider == "claude" else "claude"
+            if self.st.get("pool_" + other):
+                roots[other] = self.st["pool_" + other]
+            return resume_settings(self.provider, found, self.provider, load_catalog(roots))
+        except Exception:  # noqa: BLE001 — fail open: no settings, the launch's own options
+            self.dbg("settings: " + traceback.format_exc().replace("\n", " | "))
+            return None
+
+    def pace_of(self, verdict):
+        """``verdict``'s Pacing: the memory verdict's own, or the transcript's."""
+        return self.memory_pace if verdict["class"] == "memory" else self.pace
 
     def hold(self, verdict, **fields):
-        if not self.hold_logged:
-            self.hold_logged = True
+        pace = self.pace_of(verdict)
+        if not pace.held:
+            pace.held = True
             self.log("hold", **dict({"class": verdict["class"], "sid": self.sid,
                                      "acct": self.acct}, **fields))
 
+    def waits_for_main(self, verdict, age):
+        """Whether ``verdict`` waits for the main thread's own work in flight (main_busy): a
+        request, a reply still streaming, a tool one started. Stopping the client now would
+        cut it off (a tool's processes die with it). An agent's account verdict waits up to
+        SUBAGENT_CAP from its detection (``age``): the account accepted that work before the
+        limit, and the main thread meets the limit on its next request anyway, whose rejection
+        then stands in this one's place. A memory verdict waits as memory_waits says. Logged
+        once, as hold reason=main-<request|stream|tool|compact>."""
+        if verdict["class"] == "memory":
+            busy = self.memory_waits()
+        elif verdict.get("src") == "sidechain" and age < self.cfg.subagent_cap:
+            busy = self.main_busy()
+        else:
+            busy = None
+        if busy is None:
+            return False
+        pace = self.pace_of(verdict)
+        if not pace.waited:
+            pace.waited = True
+            self.log("hold", **{"class": verdict["class"], "sid": self.sid, "acct": self.acct,
+                                "reason": "main-" + busy})
+        return True
+
+    def memory_waits(self):
+        """What the memory verdict waits for, or None: the main thread's work in flight
+        (main_busy), else a compaction under way, which only the pane's spinner shows
+        (/compact is the banner's other remedy, and the transcript has nothing of it until it
+        is done). Each wait is capped at MEMORY_BUSY_CAP -- the process may not last much
+        longer -- counted from the first reading that found it, never from the detection: time
+        the verdict spent held for want of room or behind a transcript verdict spends none of
+        it, and work that starts later gets its own. The main thread found idle ends its wait."""
+        now = self.r.now()
+        busy = self.main_busy()
+        if busy is None:
+            self.memory_busy_since = None
+            busy, since = "compact", self.memory_compact_since
+            if since is None:
+                return None
+        else:
+            if self.memory_busy_since is None:
+                self.memory_busy_since = now
+            since = self.memory_busy_since
+        return busy if now - since < self.cfg.memory_busy_cap else None
+
     def decide(self):
-        """Act on the pending verdict once it has stood long enough; None = keep going."""
+        """Act on the pending verdict once it has stood long enough; None = keep going. The
+        transcript's verdict comes first; the memory verdict (watch_memory) is acted on only
+        while there is none: a relaunch for any reason ends the process it is about."""
         verdict = self.tracker.pending
         now = self.r.now()
+        memory = verdict is None
+        if not memory:
+            self.memory_busy_since = None  # a wait behind this one is no wait for the main thread
+        if self.provider == "claude" and not memory:
+            # Its reset passed while it waited (the grace, a hold for want of room): the
+            # limit is gone, and so is the reason to stop the session.
+            dropped, promoted = self.tracker.expire(now)
+            if dropped:
+                self.dbg("quota verdict dropped: its reset has passed")
+                self.pace.held, self.pace.probed = False, None
+                if promoted is not None:
+                    self.on_event(("error", promoted), verdict)
+                return None
+        if memory:
+            verdict = self.memory
+        since = self.memory_since if memory else self.tracker.pending_since
         cls = verdict["class"]
-        age = now - self.tracker.pending_since
+        age = now - since
         need = self.cfg.grace
         if cls == "transient":
             need = max(need, ladder_wait(self.st["hist"], now, self.cfg.transient_ladder))
         if age < need:
             return None
+        if verdict.get("src") == "sidechain" and (self.side_behind or self.tail.behind > 0):
+            # Lines not read yet may answer it (a watcher restarted onto a session replays
+            # hours of agent transcripts, SIDE_BYTES a tick): it is acted on once all are read.
+            return None
+        if memory and (self.tail is None or self.tail.behind > 0):
+            return None  # what the main thread is doing is read to the transcript's end first
         ok, why = budget_check(cls, self.st["depth"], self.st["hist"], now, self.cfg)
         if not ok:
             if why == "depth":
                 self.giveup("depth", depth=self.st["depth"], sid=self.sid)
+            if memory:
+                # More of them in an hour than MEMORY_PER_HOUR: the session comes back as heavy
+                # as it left (a resumed transcript can be). This process is left as it is, and
+                # its watcher goes on with the transcript's verdicts.
+                self.memory_off = True
+                self.drop_memory()
+                self.log("giveup", reason=why, sid=self.sid, acct=self.acct, **{"class": cls})
+                return None
             self.hold(verdict, reason=why)
             return None
         if cls in ("model", "transient") and age < self.cfg.subagent_cap \
                 and self.subagents_busy(now):
             return None
-        if self.last_probe is not None and now - self.last_probe < self.cfg.hold_reprobe:
+        if self.waits_for_main(verdict, age):
+            return None
+        pace = self.pace_of(verdict)
+        if pace.probed is not None and now - pace.probed < self.cfg.hold_reprobe:
             return None
-        self.last_probe = now
-        argv = self.build_relaunch_argv(cls)
+        pace.probed = now
+        argv = self.build_relaunch_argv(cls, verdict.get("size") if memory else None)
         if argv is None:
             self.giveup("argv", sid=self.sid)
         if cls in ROTATE:
@@ -1787,7 +2855,7 @@ class Watcher:
             avoid = avoid_merge(self.st["avoid"], now)
         cwd = self.session_cwd()
         if cwd is None:
-            self.giveup("cwd", sid=self.sid)
+            return self.refuse(verdict, "cwd", sid=self.sid)
         rc, out = self.r.run([self.st["self"]] + argv, self.cfg.probe_timeout,
                              env=probe_env(self.env, self.provider, avoid), cwd=cwd)
         pick, tier = parse_probe(out)
@@ -1803,7 +2871,18 @@ class Watcher:
         # The probe can take seconds: whatever the session wrote meanwhile (the user
         # typing, auto-continue getting through) is read before anything is stopped.
         self.read()
-        if self.tracker.pending is not verdict or not self.r.alive(self.pid):
+        if not self.r.alive(self.pid):
+            return None
+        if memory:
+            # ...and the pane is read once more: a transcript verdict now goes first, and the
+            # banner must still be up (/compact may have brought the heap down meanwhile),
+            # with the main thread still idle.
+            if self.tracker.pending is not None:
+                return None
+            self.memory_update(self.memory_reading(), self.r.now())
+            if self.memory is not verdict or self.waits_for_main(verdict, self.r.now() - since):
+                return None
+        elif self.tracker.pending is not verdict:
             return None
         return self.stop_and_relaunch(verdict, argv, avoid, probe_pick=pick)
 
@@ -1946,10 +3025,28 @@ class Watcher:
                 return False
             self.r.sleep(min(0.2, self.cfg.poll))
 
+    def refuse(self, verdict, why, **fields):
+        """A check refused to stop the session for ``verdict``, before anything was stopped.
+        Any verdict but a memory one ends the watch, as it always has (giveup, ``fields`` as
+        given). A memory verdict ends only itself: the client is left as it is and its limits,
+        logins and crashes are still watched for. The refusal is logged once (giveup
+        reason=memory-<why>), the verdict dropped, and the pane not read again for
+        MEMORY_BACKOFF s (a check that refuses now mostly refuses on the next try too). None."""
+        if verdict["class"] != "memory" or self.stopped:
+            self.giveup(why, **fields)  # raises
+        logged = {"sid": self.sid, "acct": self.acct}
+        logged.update((key, val) for key, val in fields.items() if key not in ("sid", "class"))
+        logged["class"] = "memory"
+        self.log("giveup", reason="memory-" + why, **logged)
+        self.drop_memory()
+        self.memory_compact_since = None
+        self.next_memory = self.r.now() + max(self.cfg.memory_backoff, self.cfg.memory_scan)
+        return None
+
     def stop_and_relaunch(self, verdict, argv, avoid, probe_pick="", kill=True):
-        """0 once the typed relaunch has consumed its token; GiveUp otherwise. Every check
-        that can refuse runs BEFORE the kill: a stopped session must always have its
-        relaunch."""
+        """0 once the typed relaunch has consumed its token; GiveUp otherwise -- or None, for
+        a memory verdict a check refused (refuse). Every check that can refuse runs BEFORE
+        the kill: a stopped session must always have its relaunch."""
         cls = verdict["class"]
         sock = tmux_socket(self.st["tmux"])
         # 1. The pane must still be the shell that launched the shim — otherwise the
@@ -1958,39 +3055,37 @@ class Watcher:
         #    pane runs nu or tcsh would leave it stopped with nowhere to relaunch.
         info = self.pane_info(sock) if sock else None
         if not self.pane_is_ours(info):
-            self.giveup("pane", sid=self.sid, **{"class": cls})
+            return self.refuse(verdict, "pane", sid=self.sid, **{"class": cls})
         shell = self.r.proc_status(self.st["ppid"])
         if shell is None or not is_shell(shell[2]):
-            self.giveup("pane-shell", sid=self.sid, **{"class": cls})
+            return self.refuse(verdict, "pane-shell", sid=self.sid, **{"class": cls})
         #    Only a client in the foreground of its terminal, and not stopped, is killed:
         #    one suspended with Ctrl-Z leaves another program in front, which the relaunch
         #    must not be typed into.
         if kill:
-            client = self.r.proc_status(self.pid)
-            flags = client[0] if client else ""
-            if not client or "T" in flags or flags.startswith("t") \
-                    or ("+" not in flags and not self.cfg.test_tty):
-                self.giveup("background", sid=self.sid, **{"class": cls})
+            if not self.client_in_front():
+                return self.refuse(verdict, "background", sid=self.sid, **{"class": cls})
             #    ...and only one that leads its own process group: a job of a job-control
             #    shell. Anything else (a client started by a script, `sh -c`, a pipeline
             #    stage) is not the prompt's job, and no prompt comes back when it ends.
             #    The suites' no-terminal knob waives this too: their harness has no job
             #    control to give the client a group of its own.
             if not self.cfg.test_tty and self.r.pgid(self.pid) != self.pid:
-                self.giveup("pgrp", sid=self.sid, **{"class": cls})
+                return self.refuse(verdict, "pgrp", sid=self.sid, **{"class": cls})
         #    One conversation, one client: another live process holding this session
         #    means stopping this one would not free it.
         holder = self.other_holder()
         if holder:
-            self.giveup("holder", sid=self.sid, holder=holder, **{"class": cls})
+            return self.refuse(verdict, "holder", sid=self.sid, holder=holder,
+                               **{"class": cls})
         cwd = self.session_cwd()
         if cwd is None:
-            self.giveup("cwd", sid=self.sid, **{"class": cls})
+            return self.refuse(verdict, "cwd", sid=self.sid, **{"class": cls})
         #    Last, as it is the one check that touches the pane: synchronized panes, or a
         #    tmux mode that a cancel does not end, refuse.
         why = self.pane_problem(sock, info)
         if why:
-            self.giveup(why, sid=self.sid, **{"class": cls})
+            return self.refuse(verdict, why, sid=self.sid, **{"class": cls})
         if self.switched_off():
             raise GiveUp("off")
         # 2. The relaunch file exists BEFORE the kill: a kill always has its relaunch.
@@ -2007,6 +3102,14 @@ class Watcher:
         fields.update(chain_fields(self, avoid))
         if receipt is not None:
             fields["rollout_cursor"] = "%d:%d" % (receipt.ino, receipt.off)
+        if self.provider == "claude" and self.st.get("via"):
+            # what the stopped run carried, whichever session the client switched it to since
+            # (/clear, /resume): an auth verdict parks that credential (bin/claude)
+            fields["via"] = self.st["via"]
+        if self.provider == "claude" and self.served_model:
+            # --resume restores this model, so bin/claude's model-scoped fallback judges it, not
+            # the account's default: only a session on the limited model itself gets pinned off it
+            fields["model"] = self.served_model
         if self.provider == "codex" and self.st.get("funding_tier") == "credits":
             fields.update(funding_tier="credits", funding_pid=str(self.pid))
         try:
@@ -2017,7 +3120,7 @@ class Watcher:
             else:
                 paths = write_relaunch(self.ar_dir, token, fields, argv)
         except (OSError, ValueError):
-            self.giveup("write", sid=self.sid, **{"class": cls})
+            return self.refuse(verdict, "write", sid=self.sid, **{"class": cls})
         # 3. Stop the client (a crash needs no stopping).
         if kill and not self.stop_process():
             remove_quietly(*paths)
@@ -2063,11 +3166,23 @@ class Watcher:
                 remove_quietly(*paths)
                 self.giveup("prompt", sid=self.sid, **{"class": cls})
             target = {"to_provider": self.cross_plan["provider"], "to_sid": target_sid}
+        if cls == "memory" and verdict.get("size"):
+            target["size"] = verdict["size"]
         # 7.
-        self.log("switch", **dict({"from": self.acct, "class": cls, "sid": self.sid,
-                                  "depth": int(self.st["depth"]) + 1, "probe": probe_pick or "-"}, **target))
+        self.log_switch(cls, argv, probe_pick, target)
         return 0
 
+    def log_switch(self, cls, argv, probe_pick, target):
+        """The switch line (``target``: its extra fields, a handoff's target or a memory
+        verdict's size=). model=/effort= name what the relaunched client was told to run
+        with, when it was told: the relaunch argv, or a handoff target's own."""
+        ran = (self.cross_plan["provider"], self.cross_plan.get("argv") or []) \
+            if self.cross_plan is not None else (self.provider, argv)
+        switched = dict({"from": self.acct, "class": cls, "sid": self.sid,
+                         "depth": int(self.st["depth"]) + 1, "probe": probe_pick or "-"}, **target)
+        switched.update(argv_settings(*ran))
+        self.log("switch", **switched)
+
     def on_exit(self):
         """The client is gone and not by our hand. A clean exit (/exit, SIGHUP) deletes
         claude's registry; a crash or SIGKILL leaves it behind — that is the only crash