claude-multiacc 2.0.56 → 2.0.58

package/lib/autoresume.py

@@ -57,8 +57,10 @@ 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_probe import ACCT_RE, ROTATE, parse_probe, probe_allows, probe_env, probe_exhausted
 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
 
 # ---- vocabulary ---------------------------------------------------------------------
 
@@ -127,9 +129,10 @@ MONTHS = {m: i for i, m in enumerate(
 
 STATE_KEYS = ("v", "provider", "pid", "ppid", "acct", "acct_dir", "cwd", "launched", "tmux",
               "pane", "self", "acc_root", "depth", "avoid", "hist", "chain", "funding_tier",
-              "rollout_cursor")
+              "rollout_cursor", "avoid_claude", "avoid_codex", "pool_claude", "pool_codex", "handoff_token")
 RELAUNCH_KEYS = ("v", "provider", "class", "acct", "reset", "rtype", "marked", "sid", "cwd",
-                 "depth", "avoid", "hist", "chain", "funding_tier", "funding_pid", "rollout_cursor")
+                 "depth", "avoid", "hist", "chain", "funding_tier", "funding_pid", "rollout_cursor",
+                 "avoid_claude", "avoid_codex", "pool_claude", "pool_codex", "handoff_token", "cross")
 HIST_KEEP = 32
 
 # ---- knobs --------------------------------------------------------------------------
@@ -710,10 +713,18 @@ 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."""
     kept, resume, target, prompt, i = [], False, None, False, 0
+    conservative = set()
     while i < len(argv):
         arg = argv[i]
         if arg in ("--dangerously-bypass-approvals-and-sandbox", "--yolo", "--no-daemon"):
             kept.append(arg)
+        elif arg in ("--sandbox", "--ask-for-approval"):
+            expected = "read-only" if arg == "--sandbox" else "on-request"
+            if arg in conservative or i + 1 >= len(argv) or argv[i + 1] != expected:
+                return None
+            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]):
                 return None
@@ -740,6 +751,9 @@ def codex_argv_parse(argv):
         i += 1
     if resume and target is None:
         return None  # a bare `resume` is the picker: no session to follow
+    if conservative and (len(conservative) != 2 or any(
+            arg in kept for arg in ("--yolo", "--dangerously-bypass-approvals-and-sandbox"))):
+        return None
     return kept, target
 
 
@@ -809,7 +823,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", "rollout_cursor") and key not in fields:
+        if key in RELAUNCH_KEYS[13:] 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"):
@@ -946,6 +960,8 @@ def load_state(path):
         "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", ""),
+        **{key: kv.get(key, "") for key in ("avoid_claude", "avoid_codex", "pool_claude",
+                                          "pool_codex", "handoff_token")},
     }
 
 
@@ -1409,6 +1425,7 @@ class Watcher:
         self.never_seen = set()
         self.hold_logged = False
         self.last_probe = None
+        self.cross_plan = None
         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
@@ -1775,10 +1792,14 @@ class Watcher:
                              env=probe_env(self.env, self.provider, avoid), cwd=cwd)
         pick, tier = parse_probe(out)
         self.dbg("probe rc=%s pick=%s tier=%s" % (rc, pick, tier))
-        if not probe_allows(cls, pick, tier, self.acct):
-            # Claude keeps its own auto-continue meanwhile; a cancel ends the hold.
-            self.hold(verdict, reason="no-room", pick=pick or "-", tier=tier or "-")
-            return None
+        self.cross_plan = None
+        if rc != 0 or not probe_allows(cls, pick, tier, self.acct):
+            if probe_exhausted(rc, pick, tier):
+                self.cross_plan = plan_fallback(self, verdict, avoid)
+            if self.cross_plan is None:
+                self.hold(verdict, reason="no-room", pick=pick or "-", tier=tier or "-")
+                return None
+            pick = self.cross_plan["pick"]
         # 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()
@@ -1831,8 +1852,20 @@ class Watcher:
                     doc = json.loads(fh.read(1 << 20).decode("utf-8", "replace"))
             except (OSError, ValueError):
                 continue
-            if isinstance(doc, dict) and doc.get("sessionId") == self.sid \
-                    and self.r.alive(int(name)):
+            if not isinstance(doc, dict) or doc.get("sessionId") != self.sid \
+                    or type(doc.get("pid")) is not int or doc["pid"] != int(name):
+                continue
+            registered = doc.get("startedAt")
+            if not isinstance(registered, (int, float)) or isinstance(registered, bool):
+                continue
+            started = self.r.lstart(int(name))
+            try:
+                epoch = time.mktime(time.strptime(started, "%a %b %d %H:%M:%S %Y"))
+                if not epoch <= registered / 1000.0 <= self.r.now() + 1:
+                    continue
+            except (TypeError, ValueError, OverflowError):
+                continue
+            if self.ours_alive(int(name), started):
                 return int(name)
         return None
 
@@ -1964,13 +1997,14 @@ class Watcher:
         now = self.r.now()
         token = make_token()
         receipt = None
-        if self.provider == "codex":
+        if self.provider == "codex" and self.cross_plan is None:
             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)
+        fields.update(chain_fields(self, avoid))
         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":
@@ -1978,7 +2012,10 @@ class Watcher:
         try:
             keys = send_keys_argvs(sock, self.st["pane"], self.provider, token, self.sid,
                                    self.st["self"], self.root)
-            paths = write_relaunch(self.ar_dir, token, fields, argv)
+            if self.cross_plan is not None:
+                keys, paths = prepare_cross(self, verdict, avoid, token, argv)
+            else:
+                paths = write_relaunch(self.ar_dir, token, fields, argv)
         except (OSError, ValueError):
             self.giveup("write", sid=self.sid, **{"class": cls})
         # 3. Stop the client (a crash needs no stopping).
@@ -2019,9 +2056,16 @@ class Watcher:
         # 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})
+        target = {}
+        if self.cross_plan is not None:
+            target_sid = confirm_cross(self, token, self.cross_plan)
+            if target_sid is None:
+                remove_quietly(*paths)
+                self.giveup("prompt", sid=self.sid, **{"class": cls})
+            target = {"to_provider": self.cross_plan["provider"], "to_sid": target_sid}
         # 7.
-        self.log("switch", **{"from": self.acct, "class": cls, "sid": self.sid,
-                              "depth": int(self.st["depth"]) + 1, "probe": probe_pick or "-"})
+        self.log("switch", **dict({"from": self.acct, "class": cls, "sid": self.sid,
+                                  "depth": int(self.st["depth"]) + 1, "probe": probe_pick or "-"}, **target))
         return 0
 
     def on_exit(self):

package/lib/autoresume_cross.py

@@ -0,0 +1,143 @@
+"""Quota-only planning and token preparation for an exact cross-provider handoff."""
+
+import glob
+import os
+import time
+
+from autoresume_handoff import build_handoff, validate_source
+from autoresume_probe import cross_env, parse_probe, probe_allows
+
+
+def pool_roots(watcher):
+    roots = {}
+    for provider in ('claude', 'codex'):
+        up = provider.upper()
+        value = (watcher.st.get('pool_' + provider) or watcher.env.get(up + '_ACCOUNTS_ROOT')
+                 or watcher.env.get(up + '_ACCOUNTS_DIR')
+                 or os.path.join((watcher.env.get('HOME') or '/nonexistent'), '.' + provider + '-accounts'))
+        roots[provider] = os.path.abspath(value)
+    roots[watcher.provider] = os.path.abspath(watcher.st['acc_root'])
+    return roots
+
+
+def chain_fields(watcher, avoid):
+    from autoresume import typeable
+    roots = pool_roots(watcher)
+    fields = {'pool_' + provider: root if typeable(root) else '' for provider, root in roots.items()}
+    for provider in ('claude', 'codex'):
+        fields['avoid_' + provider] = (avoid if provider == watcher.provider
+                                       else watcher.st.get('avoid_' + provider, ''))
+    return fields
+
+
+def enabled(watcher, provider, root):
+    up = provider.upper()
+    off = ('0', 'false', 'no', 'off')
+    return (watcher.env.get(up + '_MULTIACC_AUTORESUME', '1').lower() not in off
+            and watcher.env.get(up + '_MULTIACC_DISABLE', '0') != '1'
+            and not os.path.exists(os.path.join(root, 'autoresume.off'))
+            and os.path.isfile(os.path.join(root, 'accounts.json')))
+
+
+def shared_source(watcher):
+    """A cross-provider new chat must not fork a source conversation held by another TUI."""
+    if watcher.provider == 'claude':
+        return watcher.other_holder()
+    from autoresume import load_state, rollout_meta
+    rows = {pid: (parent, started) for pid, parent, started in watcher.r.ps_table()}
+    for claim in glob.glob(os.path.join(watcher.ar_dir, '*.rollout')):
+        if claim == watcher.claim:
+            continue
+        state = load_state(claim[:-8] + '.state')
+        if not state or state['provider'] != watcher.provider or state['acc_root'] != watcher.st['acc_root'] \
+                or os.path.basename(claim) != str(state['pid']) + '.rollout':
+            continue
+        identity = rows.get(state['pid'])
+        if not identity or identity[0] != state['ppid'] or not identity[1] or watcher.r.gone(state['pid']):
+            continue
+        try:
+            epoch = time.mktime(time.strptime(identity[1], '%a %b %d %H:%M:%S %Y'))
+            if epoch > state['launched'] + 1:
+                continue
+            with open(claim, encoding='utf-8') as stream:
+                meta = rollout_meta(stream.read(16384).strip())
+        except (OSError, ValueError, OverflowError):
+            continue
+        if meta and meta['id'] == watcher.sid and watcher.r.lstart(state['pid']) == identity[1]:
+            return state['pid']
+    return None
+
+
+def plan_fallback(watcher, verdict, source_avoid):
+    from autoresume import avoid_merge, typeable
+    if verdict['class'] != 'quota' or watcher.env.get(
+            watcher.provider.upper() + '_MULTIACC_CROSS_PROVIDER', '1').lower() in ('0', 'false', 'no', 'off'):
+        return None
+    target = 'claude' if watcher.provider == 'codex' else 'codex'
+    roots = pool_roots(watcher)
+    if os.path.realpath(roots['claude']) == os.path.realpath(roots['codex']):
+        return None
+    if not all(typeable(root) and enabled(watcher, provider, root) for provider, root in roots.items()):
+        return None
+    shim = os.path.join(os.path.dirname(watcher.st['self']), target)
+    if not typeable(shim) or not os.path.isfile(shim) or not os.access(shim, os.X_OK):
+        return None
+    if shared_source(watcher):
+        watcher.hold(verdict, reason='shared-source')
+        return None
+    handoff = build_handoff(watcher.provider, target, watcher.argv, watcher.sid, watcher.transcript,
+                            watcher.session_cwd(), inode=watcher.tail.ino if watcher.tail else None,
+                            prompt_override=watcher.cfg.prompt)
+    if not handoff:
+        watcher.hold(verdict, reason='handoff-history-or-permissions')
+        return None
+    avoid = avoid_merge(watcher.st.get('avoid_' + target, ''), watcher.r.now())
+    env = cross_env(watcher.env, roots)
+    env[target.upper() + '_MULTIACC_AR_PROBE'] = '1'
+    env[target.upper() + '_MULTIACC_AR_AVOID'] = avoid
+    rc, out = watcher.r.run([shim] + handoff['argv'], watcher.cfg.probe_timeout,
+                             env=env, cwd=handoff['history']['cwd'])
+    pick, tier = parse_probe(out)
+    if rc != 0 or not probe_allows('quota', pick, tier, ''):
+        return None
+    return dict(handoff, provider=target, root=roots[target], roots=roots, shim=shim,
+                avoid=avoid, source_avoid=source_avoid, pick=pick)
+
+
+def revalidate(watcher, plan):
+    history = plan['history']
+    current = validate_source(watcher.provider, watcher.sid, watcher.transcript,
+                              watcher.session_cwd(), inode=history['inode'])
+    return (current is not None and current['offset'] >= history['offset'] and not shared_source(watcher)
+            and all(enabled(watcher, provider, root) for provider, root in plan['roots'].items()))
+
+
+def prepare(watcher, verdict, avoid, token, source_argv):
+    from autoresume import hist_append, relaunch_fields, remove_quietly, send_keys_argvs
+    from autoresume import tmux_socket, write_relaunch
+    from autoresume_cross_dispatch import save_dispatch
+    plan = watcher.cross_plan
+    if not revalidate(watcher, plan):
+        raise ValueError('handoff source or target changed')
+    fields = relaunch_fields(watcher.provider, verdict, watcher.acct, watcher.sid,
+                             plan['history']['cwd'], watcher.st['depth'], avoid,
+                             hist_append(watcher.st['hist'], verdict['class'], watcher.r.now()), watcher.chain)
+    fields.update(chain_fields(watcher, avoid), cross=token)
+    if watcher.provider == 'codex' and watcher.st.get('funding_tier') == 'credits':
+        fields.update(funding_tier='credits', funding_pid=str(watcher.pid))
+    target_fields = dict(fields, provider=plan['provider'], acct='', avoid=plan['avoid'], cross='',
+                         handoff_token=token, funding_tier='', funding_pid='', rollout_cursor='')
+    target_dir = os.path.join(plan['root'], 'tmp', 'autoresume')
+    paths = []
+    try:
+        target_paths = write_relaunch(target_dir, token, target_fields, plan['argv'])
+        paths.extend(target_paths)
+        source_paths = write_relaunch(watcher.ar_dir, token, fields, source_argv)
+        paths = list(source_paths) + paths
+        paths.append(save_dispatch(watcher, plan, token))
+    except (OSError, ValueError):
+        remove_quietly(*paths)
+        raise
+    keys = send_keys_argvs(tmux_socket(watcher.st['tmux']), watcher.st['pane'], watcher.provider,
+                           token, watcher.sid, watcher.st['self'], watcher.root)
+    return keys, paths

package/lib/autoresume_cross_dispatch.py

@@ -0,0 +1,114 @@
+"""Single-use source-to-target dispatch and target startup identity; no transcript text is logged."""
+
+import argparse
+import json
+import os
+import stat
+import sys
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from autoresume_probe import cross_env, handoff_settings
+
+
+def save_dispatch(watcher, plan, token):
+    from autoresume import _atomic_write
+    path = os.path.join(watcher.ar_dir, 'r-' + token + '.cross.json')
+    payload = {'v': 1, 'token': token, 'source_provider': watcher.provider,
+               'source_root': os.path.abspath(watcher.st['acc_root']), 'sid': watcher.sid,
+               'target_provider': plan['provider'], 'target_root': plan['root'],
+               'target_shim': plan['shim'], 'roots': plan['roots'], 'cwd': plan['history']['cwd'],
+               'settings': handoff_settings(watcher.env, plan['roots'])}
+    _atomic_write(path, json.dumps(payload, sort_keys=True).encode())
+    return path
+
+
+def read_dispatch(root, token):
+    from autoresume import TOKEN_RE, typeable, uuid_ok
+    if not TOKEN_RE.fullmatch(token):
+        raise ValueError('invalid handoff token')
+    path = os.path.join(root, 'tmp', 'autoresume', 'r-' + token + '.cross.json')
+    info = os.lstat(path)
+    if not stat.S_ISREG(info.st_mode) or info.st_uid != os.getuid() or info.st_mode & 0o077 \
+            or not 0 <= time.time() - info.st_mtime <= 600 or info.st_size > 65536:
+        raise ValueError('invalid handoff payload identity')
+    with open(path, encoding='utf-8') as stream:
+        payload = json.load(stream)
+    source, target = payload.get('source_provider'), payload.get('target_provider')
+    if payload.get('v') != 1 or payload.get('token') != token or source not in ('claude', 'codex') \
+            or target not in ('claude', 'codex') or source == target or not uuid_ok(payload.get('sid')):
+        raise ValueError('invalid handoff payload')
+    if os.path.abspath(root) != payload.get('source_root') or not typeable(payload.get('target_root')):
+        raise ValueError('handoff pool changed')
+    expected = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'bin', target)
+    if os.path.realpath(payload.get('target_shim', '')) != os.path.realpath(expected):
+        raise ValueError('handoff target is not this installation')
+    roots = payload.get('roots', {})
+    if set(roots) != {'claude', 'codex'} or roots[source] != os.path.abspath(root) \
+            or roots[target] != payload['target_root'] or not all(typeable(value) for value in roots.values()):
+        raise ValueError('invalid handoff pool roots')
+    return path, payload
+
+
+def dispatch(root, token):
+    path, payload = read_dispatch(root, token)
+    from autoresume import remove_quietly
+    env = cross_env(os.environ, payload['roots'])
+    settings = handoff_settings(payload.get('settings', {}), payload['roots'])
+    env.update(settings)
+    target = payload['target_provider']
+    up = target.upper()
+    if env.get(up + '_MULTIACC_AUTORESUME', '1').lower() in ('0', 'false', 'no', 'off') \
+            or env.get(up + '_MULTIACC_DISABLE', '0') == '1' \
+            or os.path.exists(os.path.join(payload['target_root'], 'autoresume.off')):
+        raise ValueError('handoff target disabled')
+    claimed = path + '.used'
+    os.rename(path, claimed)
+    try:
+        env[up + '_MULTIACC_AR'] = token + ':' + payload['sid']
+        os.chdir(payload['cwd'])
+        remove_quietly(claimed)
+        os.execve(payload['target_shim'], [payload['target_shim']], env)
+    finally:
+        remove_quietly(claimed)
+
+
+def startup(state_path, token):
+    from autoresume import TOKEN_RE, Runner, _atomic_write, load_state
+    if not TOKEN_RE.fullmatch(token):
+        raise ValueError('invalid startup token')
+    state = load_state(state_path)
+    if not state or state.get('handoff_token') != token:
+        raise ValueError('startup state is not bound to the handoff token')
+    started = Runner().lstart(state['pid'])
+    if not started:
+        raise ValueError('startup process vanished')
+    receipt = {key: state[key] for key in ('provider', 'pid', 'acct', 'pane', 'ppid', 'chain', 'depth', 'launched')}
+    receipt.update(token=token, state=os.path.abspath(state_path), started=started)
+    path = os.path.join(os.path.dirname(state_path), 'h-' + token + '.start.json')
+    _atomic_write(path, json.dumps(receipt, sort_keys=True).encode())
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    commands = parser.add_subparsers(dest='command', required=True)
+    sub = commands.add_parser('dispatch')
+    sub.add_argument('--root', required=True)
+    sub.add_argument('--token', required=True)
+    sub = commands.add_parser('startup')
+    sub.add_argument('--state', required=True)
+    sub.add_argument('--token', required=True)
+    args = parser.parse_args()
+    try:
+        if args.command == 'dispatch':
+            dispatch(args.root, args.token)
+        else:
+            startup(args.state, args.token)
+    except (OSError, ValueError, KeyError, TypeError):
+        print('claude-multiacc: cross-provider handoff could not start safely', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

package/lib/autoresume_cross_receipt.py

@@ -0,0 +1,138 @@
+"""A handoff succeeds only when its new client persists the exact handoff user prompt."""
+
+import glob
+import json
+import os
+import stat
+
+from autoresume_receipt import codex_prompt_record
+
+
+def read_start(watcher, token, plan):
+    from autoresume import load_state
+    directory = os.path.join(plan['root'], 'tmp', 'autoresume')
+    path = os.path.join(directory, 'h-' + token + '.start.json')
+    try:
+        info = os.lstat(path)
+        if not stat.S_ISREG(info.st_mode) or info.st_uid != os.getuid() or info.st_mode & 0o077:
+            return None
+        with open(path, encoding='utf-8') as stream:
+            receipt = json.load(stream)
+        state_path = receipt.get('state', '')
+        if os.path.dirname(state_path) != directory or not state_path.endswith('.state'):
+            return None
+        state = load_state(state_path)
+        if not state or receipt.get('token') != token or state.get('handoff_token') != token:
+            return None
+        for key in ('provider', 'pid', 'acct', 'pane', 'ppid', 'chain', 'depth', 'launched'):
+            if receipt.get(key) != state[key]:
+                return None
+        if state['provider'] != plan['provider'] or state['acc_root'] != plan['root'] \
+                or state['chain'] != watcher.chain or state['depth'] != int(watcher.st['depth']) + 1 \
+                or state['pane'] != watcher.st['pane'] or state['ppid'] != watcher.st['ppid']:
+            return None
+        if os.path.realpath(state['acct_dir']) != os.path.realpath(os.path.join(plan['root'], state['acct'])) \
+                or os.path.realpath(state['self']) != os.path.realpath(plan['shim']) \
+                or os.path.realpath(state['cwd']) != plan['history']['cwd'] \
+                or state['tmux'] != watcher.st['tmux']:
+            return None
+        if os.path.basename(state_path) != str(state['pid']) + '.state' \
+                or not isinstance(receipt.get('started'), str) or not receipt['started'] \
+                or watcher.r.gone(state['pid']) or watcher.r.lstart(state['pid']) != receipt['started']:
+            return None
+        return receipt, state
+    except (OSError, ValueError, TypeError, AttributeError, KeyError):
+        return None
+
+
+def target_history(watcher, receipt, state, plan):
+    from autoresume import iso_to_epoch, rollout_meta, uuid_ok
+    directory = os.path.dirname(receipt['state'])
+    if state['provider'] == 'codex':
+        try:
+            with open(os.path.join(directory, str(state['pid']) + '.rollout'), encoding='utf-8') as stream:
+                path = stream.read(16384).strip()
+        except OSError:
+            return None
+        meta = rollout_meta(path)
+        if not meta or os.path.commonpath((os.path.realpath(path), os.path.realpath(
+                os.path.join(state['acct_dir'], 'sessions')))) != os.path.realpath(
+                    os.path.join(state['acct_dir'], 'sessions')):
+            return None
+        stamp = iso_to_epoch(meta.get('timestamp'))
+        if stamp is None or stamp < state['launched'] - 2:
+            return None
+        return path, meta['id']
+    try:
+        path = os.path.join(state['acct_dir'], 'sessions', str(state['pid']) + '.json')
+        with open(path, encoding='utf-8') as stream:
+            record = json.load(stream)
+        started = record.get('startedAt')
+        if record.get('pid') != state['pid'] or not isinstance(started, (float, int)) \
+                or started / 1000 < state['launched'] - 2 or not uuid_ok(record.get('sessionId')):
+            return None
+        if os.path.realpath(record.get('cwd', '')) != plan['history']['cwd']:
+            return None
+        paths = glob.glob(os.path.join(state['acct_dir'], 'projects', '*', record['sessionId'] + '.jsonl'))
+        return (paths[0], record['sessionId']) if len(paths) == 1 else None
+    except (OSError, ValueError, TypeError, AttributeError):
+        return None
+
+
+def claude_prompt_record(raw, prompt, sid):
+    try:
+        record = json.loads(raw)
+    except (ValueError, TypeError):
+        return False
+    if not isinstance(record, dict) or record.get('type') != 'user' or record.get('sessionId') != sid \
+            or record.get('isSidechain') is True or record.get('agentId'):
+        return False
+    message = record.get('message')
+    if not isinstance(message, dict) or message.get('role') != 'user':
+        return False
+    content = message.get('content')
+    if isinstance(content, str):
+        return content == prompt
+    return isinstance(content, list) and any(isinstance(block, dict) and block.get('type') == 'text'
+                                            and block.get('text') == prompt for block in content)
+
+
+def unchanged_tail(tail, inode):
+    try:
+        current = os.stat(tail.path)
+        return current.st_ino == inode and current.st_size >= tail.off
+    except OSError:
+        return False
+
+
+def confirm_cross(watcher, token, plan):
+    from autoresume import JsonlTail, iso_to_epoch
+    from autoresume_handoff import validate_source
+    deadline = watcher.r.now() + watcher.cfg.prompt_wait
+    tail, bound = None, None
+    while True:
+        started = read_start(watcher, token, plan)
+        history = target_history(watcher, *started, plan) if started else None
+        if history and history[1] != watcher.sid:
+            path, sid = history
+            validated = validate_source(plan['provider'], sid, path, plan['history']['cwd'])
+            if validated and bound is None:
+                bound = (path, sid, validated['inode'], started[0]['started'])
+                tail = JsonlTail(path)
+            if validated and bound == (path, sid, validated['inode'], started[0]['started']):
+                if not unchanged_tail(tail, bound[2]):
+                    return None
+                for raw in tail.read_lines():
+                    try:
+                        stamp = iso_to_epoch(json.loads(raw).get('timestamp'))
+                    except (ValueError, TypeError, AttributeError):
+                        continue
+                    if stamp is None or stamp < started[1]['launched'] - 2:
+                        continue
+                    matched = (codex_prompt_record(raw, plan['argv'][-1]) if plan['provider'] == 'codex'
+                               else claude_prompt_record(raw, plan['argv'][-1], sid))
+                    if matched and unchanged_tail(tail, bound[2]) and read_start(watcher, token, plan):
+                        return sid
+        if watcher.switched_off() or watcher.r.now() >= deadline:
+            return None
+        watcher.r.sleep(min(0.2, watcher.cfg.poll))