claude-multiacc 2.0.53 → 2.0.55

package/README.md

@@ -452,9 +452,10 @@ Every other launch, including `-p` and `codex exec`, runs exactly as before.
 
 **How it works.**
 
-- **Launch.** The shim's `exec` is unchanged. Just before it, a detached watcher starts
+- **Launch.** Just before the shim's `exec`, a detached watcher starts
   (`lib/autoresume.py`, which needs `python3`). It reads that run's transcript (codex: its
-  rollout).
+  rollout). Supervised Codex launches add `--no-daemon` when the installed CLI supports
+  it, so the client owns the task and rollout through account changes.
 - **Probe.** Once an error settles, the watcher asks the shim, in probe mode, whether
   another account has headroom, including the 90–99% fallback for quota errors. If none
   does, it **holds** and Claude's own "continuing automatically at …" carries on.
@@ -464,7 +465,8 @@ Every other launch, including `-p` and `codex exec`, runs exactly as before.
   `/limit-reset`.
 - **Resume.** The relaunched shim parks the old account with the usual markers, then runs
   normal selection minus the account it just left. The session resumes with a short
-  prompt telling the model it was restarted and should continue.
+  prompt telling the model it was restarted and should continue. Codex reports a
+  successful switch only after that prompt appears as a new user message in its rollout.
 
 Every step appends an `autoresume <event>` line to `selection.log`.
 

package/bin/codex

@@ -737,7 +737,7 @@ auth_dead() { expired_marked "$1"; }
 # An interactive codex that runs into a usage limit or a dead login does NOT exit: the
 # TUI stays open on "You've hit your usage limit ... try again at <date>" and waits for a
 # human. Auto-resume moves that session — same session id — onto another pooled account
-# without a keystroke, and it does so without touching the exec below: the real codex
+# without a keystroke. A supported client uses --no-daemon; the real codex
 # still replaces this shim (same pid, same terminal), while a detached watcher
 # (lib/autoresume.py) tails the session's rollout beside it. On a limit/auth verdict the
 # watcher asks THIS shim which account a relaunch would get (probe mode), stops codex, and
@@ -747,8 +747,8 @@ auth_dead() { expired_marked "$1"; }
 # file carrying the verdict and the argv (`resume <kept opts> <sid> <prompt>`); the old
 # account is parked the way the exec retry path below parks one, and ordinary selection
 # picks the next account. bin/claude carries the same hooks; docs/AUTORESUME.md is the
-# reference. Fail open everywhere: nothing here may block before exec — no network, no
-# waiting, no python in the foreground — and every path that cannot finish falls through
+# reference. Fail open everywhere: no network; the local CLI mode probe is bounded to
+# two seconds, and every path that cannot finish falls through
 # to exactly today's exec. The one exception is a typed relaunch whose token is gone: it
 # names the session to resume and exits 2, because its own (empty) argv would start a
 # fresh session in the stopped one's place.
@@ -759,6 +759,8 @@ AR_HIST=""          # class:epoch,... — the chain's verdicts, for the watcher'
 AR_CHAIN=""         # the chain's id, as the watcher named it
 AR_ARGV=()
 AR_ORIG_ARGV=()
+AR_NO_DAEMON=0
+AR_ROLLOUT_CURSOR=""
 AR_TIER=""          # which cut produced the pick: eligible | soft | hard (probe answer)
 AR_R_SID=""         # the session a relaunch file named, for the dead-token hint
 AR_PROBE=0
@@ -922,6 +924,7 @@ ar_relaunch() { # $1 token
       chain) ar_word_ok "$v" 1 && chain="$v" ;;
       funding_tier) [ "$v" = credits ] && funding=credits ;;
       funding_pid) num_ok "$v" && funding_pid="$v" ;;
+      rollout_cursor) case "$v" in *[!0-9:]*|'') ;; *) AR_ROLLOUT_CURSOR="$v" ;; esac ;;
     esac
   done < "$f"
   age=$((now - $(file_mtime "$f")))
@@ -984,7 +987,7 @@ ar_argv_ok() { # the argv codex is about to get
       continue
     fi
     case "$a" in
-      --dangerously-bypass-approvals-and-sandbox|--yolo) ;;
+      --dangerously-bypass-approvals-and-sandbox|--yolo|--no-daemon) ;;
       -m|--model) want=1 ;;
       --model=?*) ;;
       --last)
@@ -1069,6 +1072,20 @@ ar_spawn_watcher() { # $1 provider, $2 picked acct dir, then the argv codex is a
   root="$ACC_ROOT"
   case "$root" in /*) ;; *) root="$PWD/$root" ;; esac
   ar_path_ok "$SELF" && ar_path_ok "$root" || return 1
+  # A shared daemon outlives the TUI and owns its rollout. Keep supervised clients
+  # local so discovery, account rotation and the resume prompt have one owner.
+  local mode="" arg explicit=0
+  for arg in "$@"; do [ "$arg" != --no-daemon ] || explicit=1; done
+  if [ "$explicit" = 0 ] && [ -f "$SELF_DIR/../lib/codex_autoresume_mode.py" ]; then
+    mode="$("$AR_PY" -I "$SELF_DIR/../lib/codex_autoresume_mode.py" "$REAL" 2>/dev/null)" || mode=""
+    if [ "$mode" = --no-daemon ]; then
+      if [ "${#AR_ORIG_ARGV[@]}" -gt 0 ]; then
+        AR_ORIG_ARGV=(--no-daemon "${AR_ORIG_ARGV[@]}")
+      else
+        AR_ORIG_ARGV=(--no-daemon)
+      fi
+    fi
+  fi
   [ -d "$AR_DIR" ] || mkdir -p "$AR_DIR" 2>/dev/null || return 1
   st="$AR_DIR/$$.state"
   # The ORIGINAL argv (A2), NUL-separated: the watcher rebuilds the relaunch from it.
@@ -1086,6 +1103,7 @@ ar_spawn_watcher() { # $1 provider, $2 picked acct dir, then the argv codex is a
     printf 'tmux=%s\npane=%s\nself=%s\nacc_root=%s\n' "$TMUX" "$TMUX_PANE" "$SELF" "$root"
     printf 'depth=%s\navoid=%s\nhist=%s\nchain=%s\n' "$AR_DEPTH" "$AR_AVOID" "$AR_HIST" "$AR_CHAIN"
     printf 'funding_tier=%s\n' "$AR_TIER"
+    printf 'rollout_cursor=%s\n' "$AR_ROLLOUT_CURSOR"
   } 2>/dev/null > "$st.tmp" && mv -f "$st.tmp" "$st" 2>/dev/null || {
     rm -f "$st.tmp" "$AR_DIR/$$.argv" 2>/dev/null
     return 1
@@ -1094,6 +1112,7 @@ ar_spawn_watcher() { # $1 provider, $2 picked acct dir, then the argv codex is a
   # and the watcher ignores the terminal's signals until its own setsid().
   ( trap '' INT QUIT HUP TSTP
     exec "$AR_PY" -I "$lib" watch --state "$st" </dev/null >/dev/null 2>&1 & ) >/dev/null 2>&1
+  [ "$mode" != --no-daemon ] || AR_NO_DAEMON=1
   return 0
 }
 
@@ -1486,9 +1505,11 @@ share_state_index "$pick"
 if [ "$wants_retry" = "0" ]; then
   export CODEX_HOME="$pick"
   # Auto-resume: a gated, detached watcher beside this exec — the exec itself (same pid,
-  # same argv, same environment minus the auto-resume variables) is unchanged.
+  # same environment minus the auto-resume variables). Supported clients own their
+  # task through --no-daemon, including the continuation passed on resume.
   ar_spawn_watcher codex "$pick" "$@" || true
   ar_scrub_env
+  [ "$AR_NO_DAEMON" != 1 ] || set -- --no-daemon "$@"
   exec "$REAL" "$@"
 fi
 

package/docs/AUTORESUME.md

@@ -47,16 +47,23 @@ shell:   runs the shim again → token → marker on the old account → normal
          the accounts this chain left → exec … --resume <sid> "<prompt>"   (with a new watcher)
 ```
 
-1. **The launch is unchanged.** The shim selects exactly as before. It then `exec`s the
-   real binary with the same pid, stdin/stdout and exit-code passthrough.
+1. **The shim selects an account and supervises the client.** It `exec`s the real
+   binary with the same pid, stdin/stdout and exit-code passthrough.
+
+   For Codex launches that pass all watcher gates, the shim checks the real CLI's local
+   `--help` under a two-second timeout. If supported, it adds `--no-daemon` and preserves
+   that flag on resume. Current Codex otherwise runs tasks in a shared background
+   daemon: the TUI holds no rollout file, and reconnecting can leave the continuation
+   prompt unsubmitted. A supervised client needs its own task process. Older CLIs,
+   disabled auto-resume, and launches outside the gates keep their existing arguments.
 
    Just before the exec, it writes a small state file to `<pool>/tmp/autoresume/`: the
    pid, account, cwd, tmux pane and original argv. It then starts the watcher fully
    detached.
 
-   Nothing on this path waits, runs python in the foreground or touches the network (a
-   relaunch adds one short trust step, see below). A failed check means no watcher, never
-   a failed launch.
+   The capability check runs locally through Python, without network access or an
+   account request. A failed check leaves the CLI arguments unchanged. A failed watcher
+   gate means no watcher, never a failed launch.
 2. **The watcher reads what the client already writes.**
    - **Claude:** `<acct>/sessions/<pid>.json` names the session. The watcher re-reads it
      every tick, so it follows `/clear` and `/resume` inside the TUI. The transcript
@@ -69,7 +76,9 @@ shell:   runs the shim again → token → marker on the old account → normal
 
    In both cases:
    - Only records written after this launch count, so an old rejection in a resumed
-     transcript never fires.
+     transcript never fires. An automatic Codex restart also carries the previous
+     rollout's inode and byte offset: the new watcher starts after those bytes, so a
+     quota event from the same second cannot trigger another rotation.
    - Subagent (sidechain) records are ignored.
 3. **It waits for the error to settle.**
    - **Grace period:** a verdict has to stand for 5 s.
@@ -144,6 +153,11 @@ shell:   runs the shim again → token → marker on the old account → normal
       trust?" in a directory an account has never opened, even with
       `--dangerously-skip-permissions`, and nobody is there to answer.
    6. The new pick gets a watcher of its own.
+   7. For Codex, the old watcher waits up to 30 seconds for the exact continuation
+      prompt to appear as a new user message in the same rollout. Only then does it log
+      `switch`. An unsubmitted prompt logs `giveup reason=prompt` and displays a resume
+      hint; it never sends more keys into the TUI. Historical prompts, tool output and
+      a replaced or truncated rollout cannot confirm a restart.
 
    A token that is missing, malformed or older than 10 minutes starts nothing. The shim
    prints `claude-multiacc: auto-resume could not continue automatically (the resume token
@@ -160,6 +174,7 @@ The relaunch starts from the original argv:
 - `--resume <sid> "<prompt>"` is appended. For codex the command becomes
   `resume <options> <sid> "<prompt>"`.
 - An explicit `--model` from the original launch is kept. No model is added otherwise.
+- Codex's explicit or automatically selected `--no-daemon` is kept.
 
 The prompt is submitted automatically:
 

package/lib/autoresume.py

@@ -4,7 +4,7 @@
 An interactive ``claude`` or ``codex`` that runs into a usage limit does NOT exit. Claude
 idles on "continuing automatically at <reset>" (which can be days away) and codex sits on
 "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 byte-identical
+(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:
 
@@ -58,6 +58,7 @@ import traceback
 # -I omits the script directory; load only helpers from this installation.
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from autoresume_probe import ACCT_RE, ROTATE, parse_probe, probe_allows, probe_env
+from autoresume_receipt import apply_cursor, confirm_prompt, receipt_tail
 
 # ---- vocabulary ---------------------------------------------------------------------
 
@@ -125,9 +126,10 @@ MONTHS = {m: i for i, m in enumerate(
     ("jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"), 1)}
 
 STATE_KEYS = ("v", "provider", "pid", "ppid", "acct", "acct_dir", "cwd", "launched", "tmux",
-              "pane", "self", "acc_root", "depth", "avoid", "hist", "chain", "funding_tier")
+              "pane", "self", "acc_root", "depth", "avoid", "hist", "chain", "funding_tier",
+              "rollout_cursor")
 RELAUNCH_KEYS = ("v", "provider", "class", "acct", "reset", "rtype", "marked", "sid", "cwd",
-                 "depth", "avoid", "hist", "chain", "funding_tier", "funding_pid")
+                 "depth", "avoid", "hist", "chain", "funding_tier", "funding_pid", "rollout_cursor")
 HIST_KEEP = 32
 
 # ---- knobs --------------------------------------------------------------------------
@@ -152,6 +154,7 @@ KNOBS = {
     "SUBAGENT_QUIET": 20.0,
     "SUBAGENT_CAP": 900.0,
     "RELAUNCH_WAIT": 10.0,
+    "PROMPT_WAIT": 30.0,
 }
 LADDER_DEFAULT = (30.0, 60.0, 120.0)
 # After DISCOVER_TIMEOUT a codex watcher still looks for its rollout (a session first
@@ -709,7 +712,7 @@ def codex_argv_parse(argv):
     kept, resume, target, prompt, i = [], False, None, False, 0
     while i < len(argv):
         arg = argv[i]
-        if arg in ("--dangerously-bypass-approvals-and-sandbox", "--yolo"):
+        if arg in ("--dangerously-bypass-approvals-and-sandbox", "--yolo", "--no-daemon"):
             kept.append(arg)
         elif arg in ("-m", "--model"):
             if i + 1 >= len(argv) or not _value_ok(argv[i + 1]):
@@ -806,7 +809,7 @@ def format_relaunch(fields):
     value carrying a line break (or NUL) cannot be written faithfully: ValueError."""
     lines = []
     for key in RELAUNCH_KEYS:
-        if key in ("funding_tier", "funding_pid") and key not in fields:
+        if key in ("funding_tier", "funding_pid", "rollout_cursor") and key not in fields:
             continue
         val = "" if fields.get(key) is None else str(fields[key])
         if any(c in val for c in "\0\n\r"):
@@ -942,6 +945,7 @@ def load_state(path):
         "acc_root": acc_root, "depth": int(depth),
         "avoid": kv.get("avoid", ""), "hist": kv.get("hist", ""), "chain": chain,
         "funding_tier": "credits" if kv.get("funding_tier") == "credits" else "included",
+        "rollout_cursor": kv.get("rollout_cursor", ""),
     }
 
 
@@ -1619,6 +1623,9 @@ class Watcher:
 
     def attach(self, path, meta, how):
         self.tail = JsonlTail(path)
+        if meta["id"] == codex_resume_id(self.argv) \
+                and not apply_cursor(self.tail, self.st.get("rollout_cursor")):
+            self.giveup("rollout-replaced", sid=meta["id"])
         self.transcript = path
         self.sid = meta["id"]
         mcwd = meta.get("cwd")
@@ -1956,9 +1963,16 @@ class Watcher:
         # 2. The relaunch file exists BEFORE the kill: a kill always has its relaunch.
         now = self.r.now()
         token = make_token()
+        receipt = None
+        if self.provider == "codex":
+            receipt = receipt_tail(self.transcript, JsonlTail)
+            if receipt is None:
+                self.giveup("receipt", sid=self.sid, **{"class": cls})
         fields = relaunch_fields(self.provider, verdict, self.acct, self.sid, cwd,
                                  self.st["depth"], avoid,
                                  hist_append(self.st["hist"], cls, now), self.chain)
+        if receipt is not None:
+            fields["rollout_cursor"] = "%d:%d" % (receipt.ino, receipt.off)
         if self.provider == "codex" and self.st.get("funding_tier") == "credits":
             fields.update(funding_tier="credits", funding_pid=str(self.pid))
         try:
@@ -2002,6 +2016,9 @@ class Watcher:
                 remove_quietly(*paths)
                 self.giveup("relaunch", sid=self.sid, **{"class": cls})
             self.r.sleep(min(0.2, self.cfg.poll))
+        # Token consumption alone does not prove Codex submitted the continuation.
+        if receipt is not None and not confirm_prompt(self, receipt, argv[-1]):
+            self.giveup("prompt", sid=self.sid, **{"class": cls})
         # 7.
         self.log("switch", **{"from": self.acct, "class": cls, "sid": self.sid,
                               "depth": int(self.st["depth"]) + 1, "probe": probe_pick or "-"})

package/lib/autoresume_receipt.py

@@ -0,0 +1,78 @@
+"""Confirm that Codex persisted the continuation, without recording chat text."""
+
+import json
+import os
+import re
+
+
+def cursor_value(value):
+    if isinstance(value, str) and re.fullmatch(r"[0-9]{1,20}:[0-9]{1,20}", value):
+        return tuple(int(part) for part in value.split(":"))
+    return None
+
+
+def apply_cursor(tail, value):
+    """Resume after the previous client's bytes, including when launches share a second."""
+    if value in (None, ""):
+        return True
+    cursor = cursor_value(value)
+    if cursor is None:
+        return False
+    try:
+        state = os.stat(tail.path)
+    except OSError:
+        return False
+    inode, offset = cursor
+    if state.st_ino != inode or state.st_size < offset:
+        return False
+    tail.ino, tail.off = inode, offset
+    return True
+
+
+def receipt_tail(path, tail_type):
+    """Pin a known rollout and its pre-relaunch EOF; old messages cannot be receipts."""
+    try:
+        state = os.stat(path)
+    except (OSError, TypeError):
+        return None
+    tail = tail_type(path)
+    tail.off, tail.ino = state.st_size, state.st_ino
+    return tail
+
+
+def codex_prompt_record(raw, prompt):
+    """Accept only an actual user message, never a tool result quoting the prompt."""
+    try:
+        rec = json.loads(raw)
+    except (ValueError, TypeError):
+        return False
+    if not isinstance(rec, dict) or not isinstance(rec.get("payload"), dict):
+        return False
+    payload = rec["payload"]
+    if rec.get("type") == "event_msg" and payload.get("type") == "user_message":
+        return payload.get("message") == prompt
+    if rec.get("type") != "response_item" or payload.get("type") != "message" \
+            or payload.get("role") != "user":
+        return False
+    content = payload.get("content")
+    if not isinstance(content, list):
+        return False
+    return any(isinstance(block, dict) and block.get("type") == "input_text"
+               and block.get("text") == prompt for block in content)
+
+
+def confirm_prompt(watcher, tail, prompt):
+    """The relaunch token proves shell execution; a new user record proves submission."""
+    deadline = watcher.r.now() + watcher.cfg.prompt_wait
+    while True:
+        try:
+            state = os.stat(tail.path)
+        except OSError:
+            return False
+        if state.st_ino != tail.ino or state.st_size < tail.off:
+            return False
+        if any(codex_prompt_record(raw, prompt) for raw in tail.read_lines()):
+            return True
+        if watcher.switched_off() or watcher.r.now() >= deadline:
+            return False
+        watcher.r.sleep(min(0.2, watcher.cfg.poll))

package/lib/claude_pool_prepare.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 """Prepare one local Claude pool's shared history and interactive permission default."""
 
+from __future__ import annotations
+
 import argparse
 import fcntl
 import json

package/lib/codex_autoresume_mode.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Detect the local Codex mode that keeps a supervised TUI's work in its process tree.
+
+New Codex releases default to a shared daemon, whose rollout and background work
+outlive the terminal client. Only clients advertising ``--no-daemon`` receive it;
+older releases keep their existing command line. Help never needs credentials or
+network access. Every failure leaves the launch unchanged.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import signal
+import subprocess
+import sys
+import tempfile
+
+
+OPTION = re.compile(rb"(?m)^\s+--no-daemon(?:\s|$)")
+PROBE_TIMEOUT = 2.0
+MAX_HELP_BYTES = 1 << 20
+
+
+def supports_no_daemon(executable, timeout=PROBE_TIMEOUT):
+    """Read bounded local help; a timed-out probe kills only the group it created."""
+    try:
+        with tempfile.TemporaryFile() as output:
+            process = subprocess.Popen(
+                [executable, "--help"], stdin=subprocess.DEVNULL, stdout=output,
+                stderr=subprocess.DEVNULL, start_new_session=True, close_fds=True,
+            )
+            try:
+                code = process.wait(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                try:
+                    os.killpg(process.pid, signal.SIGKILL)
+                except ProcessLookupError:
+                    pass
+                process.wait()
+                return False
+            if code != 0:
+                return False
+            output.seek(0)
+            return OPTION.search(output.read(MAX_HELP_BYTES)) is not None
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return False
+
+
+def main(argv=None):
+    args = sys.argv[1:] if argv is None else argv
+    if len(args) == 1 and supports_no_daemon(args[0]):
+        print("--no-daemon")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.53",
+  "version": "2.0.55",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {