@team-agent/installer 0.2.2 → 0.2.3

package/src/team_agent/messaging/leader_panes.py

@@ -503,6 +503,206 @@ def _leader_command_looks_usable(command: str, provider: str) -> bool:
     return command_name in {"codex", "node", "nodejs", "claude", "claude.exe"}
 
 
+def attempt_trust_auto_answer(
+    workspace: Path,
+    pane_id: str | None,
+    pane_capture_tail: str,
+    event_log: EventLog,
+    *,
+    spec: dict[str, Any] | None = None,
+    state: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Gap 29 (Slice 2 Stage 2) — opt-in auto-answer of the codex first-run trust prompt.
+
+    Called by the inject path when developer's structured envelope reports
+    detected=='codex_trust_prompt'. Auto-answers ONLY when both:
+      (1) runtime is opted in. The PREFERRED opt-in is the per-session env var
+          TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE in {1,true,yes,on}. The legacy
+          spec.runtime.auto_trust_own_workspace=True path is still honoured for
+          backwards compatibility but is DEPRECATED (constitution-reviewer F3:
+          a YAML field permanently erases the trust prompt's cognitive moment
+          across all sessions, defeating its purpose). The spec path will be
+          removed in 0.3.0.
+      (2) the trust-prompt pane capture references this workspace's absolute path
+          (so a worker can only trust its own dir, never some arbitrary path).
+
+    On match, sends '1' + Enter to the pane and emits
+    leader_panes.trust_auto_answered. Default is opt-out — every refusal returns
+    answered=False with a structured reason and the existing failure envelope
+    bubbles up unchanged.
+
+    Return: {"ok": bool, "answered": bool, "reason": str, ...}
+    """
+    if spec is None and state is not None:
+        spec_path_str = state.get("spec_path")
+        if spec_path_str:
+            try:
+                from team_agent.spec import load_spec as _load_spec
+                spec = _load_spec(Path(spec_path_str))
+            except Exception:
+                spec = None
+    if not _auto_trust_opt_in(spec, event_log=event_log):
+        # Spark LOW #6: emit a structured event so the not-opted-in branch is
+        # as observable as the workspace_dir_mismatch / tmux_send_keys_failed
+        # branches. Keeps the decision matrix uniformly auditable.
+        event_log.write(
+            "leader_panes.trust_auto_answer_skipped",
+            pane_id=pane_id,
+            workspace=str(workspace),
+            reason="not_opted_in",
+        )
+        return {"ok": False, "answered": False, "reason": "not_opted_in"}
+    if not pane_id:
+        event_log.write(
+            "leader_panes.trust_auto_answer_skipped",
+            pane_id=None,
+            workspace=str(workspace),
+            reason="pane_id_missing",
+        )
+        return {"ok": False, "answered": False, "reason": "pane_id_missing"}
+    if not _capture_tail_references_workspace(pane_capture_tail, workspace):
+        event_log.write(
+            "leader_panes.trust_auto_answer_refused",
+            pane_id=pane_id,
+            workspace=str(workspace),
+            reason="workspace_dir_mismatch",
+        )
+        return {"ok": False, "answered": False, "reason": "workspace_dir_mismatch"}
+    answer = _tmux_inject_text(
+        str(pane_id),
+        "1",
+        "Enter",
+        f"team-agent-trust-auto-answer-{str(pane_id).strip('%') or 'pane'}",
+        attempts=1,
+        provider="fake",
+        bypass_non_input_gate=True,
+    )
+    if not answer.get("ok"):
+        error = answer.get("error") or "tmux send-keys failed"
+        event_log.write(
+            "leader_panes.trust_auto_answer_failed",
+            pane_id=pane_id,
+            workspace=str(workspace),
+            error=error,
+        )
+        return {"ok": False, "answered": False, "reason": "tmux_send_keys_failed", "error": error}
+    event_log.write(
+        "leader_panes.trust_auto_answered",
+        pane_id=pane_id,
+        workspace=str(workspace),
+        opted_in=True,
+    )
+    return {"ok": True, "answered": True, "reason": "trust_auto_answered"}
+
+
+_SPEC_OPT_IN_DEPRECATION_MESSAGE = (
+    "WARNING: spec.runtime.auto_trust_own_workspace is deprecated. "
+    "Use env TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE=1 per session instead. "
+    "Spec-field will be removed in 0.3.0."
+)
+
+
+def _auto_trust_opt_in(spec: dict[str, Any] | None, *, event_log: EventLog | None = None) -> bool:
+    """Constitution-reviewer F3 (2026-05-26): env-var per-session opt-in is the
+    preferred path. spec.runtime.auto_trust_own_workspace remains honoured for
+    backwards compatibility but emits a one-shot stderr deprecation warning AND
+    a structured trust_auto_answer_spec_opt_in_deprecated event so a normalized
+    YAML field is auditable from a fresh log."""
+    spec_opted_in = (
+        isinstance(spec, dict)
+        and bool((spec.get("runtime") or {}).get("auto_trust_own_workspace"))
+    )
+    if spec_opted_in:
+        _emit_spec_opt_in_deprecation(event_log)
+    env = os.environ.get("TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE", "").strip().lower()
+    env_opted_in = env in {"1", "true", "yes", "on"}
+    return env_opted_in or spec_opted_in
+
+
+def _emit_spec_opt_in_deprecation(event_log: EventLog | None) -> None:
+    """Emit the deprecation warning once per process. The structured event still
+    fires per call so an audit log captures every yaml-driven decision."""
+    import sys
+    global _SPEC_OPT_IN_DEPRECATION_WARNED
+    if not _SPEC_OPT_IN_DEPRECATION_WARNED:
+        try:
+            print(_SPEC_OPT_IN_DEPRECATION_MESSAGE, file=sys.stderr, flush=True)
+        except Exception:
+            pass
+        _SPEC_OPT_IN_DEPRECATION_WARNED = True
+    if event_log is not None:
+        try:
+            event_log.write(
+                "trust_auto_answer_spec_opt_in_deprecated",
+                preferred_opt_in="env:TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE",
+                deprecated_field="spec.runtime.auto_trust_own_workspace",
+                removal_target_version="0.3.0",
+            )
+        except Exception:
+            pass
+
+
+_SPEC_OPT_IN_DEPRECATION_WARNED = False
+
+
+def _reset_spec_opt_in_deprecation_state() -> None:
+    """Test-only helper: reset the per-process one-shot guard so multiple cases
+    in the same interpreter can each observe the warning. Not part of the
+    public API."""
+    global _SPEC_OPT_IN_DEPRECATION_WARNED
+    _SPEC_OPT_IN_DEPRECATION_WARNED = False
+
+
+def _capture_tail_references_workspace(tail: str, workspace: Path) -> bool:
+    """Spark MEDIUM #5: a raw substring match accepted '/repo' inside
+    '/repo-backup' and rejected symlinked / trailing-slash spellings. We now
+    canonicalize the workspace via Path.resolve, parse candidate absolute paths
+    out of the prompt tail (one token per line after stripping codex box-drawing
+    glyphs), canonicalize each candidate the same way, and only return True on
+    boundary-safe canonical equality."""
+    if not tail:
+        return False
+    workspace_canonical = _canonicalize_path(workspace)
+    if not workspace_canonical:
+        return False
+    for candidate in _candidate_paths_from_prompt(tail):
+        if _canonicalize_path(Path(candidate)) == workspace_canonical:
+            return True
+    return False
+
+
+_PATH_LINE_RE = re.compile(r"(/[\w\-./~+@]+)")
+
+
+def _candidate_paths_from_prompt(tail: str) -> list[str]:
+    """Pull every absolute-path-shaped token out of the prompt's tail. Codex
+    renders the trust prompt's directory inside box-drawing glyphs and on its
+    own line; strip leading/trailing whitespace and glyph noise before matching."""
+    paths: list[str] = []
+    for raw_line in tail.splitlines():
+        line = raw_line.strip()
+        # Codex draws box-glyph prefixes (▌ ▎ │) that need to be stripped.
+        for glyph in ("▌", "▎", "│"):
+            line = line.lstrip(glyph).strip()
+        if not line:
+            continue
+        for match in _PATH_LINE_RE.finditer(line):
+            token = match.group(1).rstrip("/")
+            if token and token not in paths:
+                paths.append(token)
+    return paths
+
+
+def _canonicalize_path(p: Path | str) -> str:
+    try:
+        resolved = Path(p).expanduser().resolve(strict=False)
+    except OSError:
+        return ""
+    text = resolved.as_posix()
+    # Strip a trailing slash so boundary-safe equality holds.
+    return text.rstrip("/") if text != "/" else "/"
+
+
 def _choose_leader_submit_key(provider: str, capture_text: str) -> tuple[str, str]:
     if provider != "codex":
         return "Enter", "non_codex_provider"

package/src/team_agent/messaging/scheduler.py

@@ -84,6 +84,18 @@ def _fire_due_scheduled_events(workspace: Path, store: MessageStore, event_log:
             elif row["kind"] == "health_ping":
                 result = {"ok": True, "status": "logged"}
                 event_log.write("coordinator.health_ping", target=row["target"], payload=payload)
+            elif row["kind"] == "trust_retry":
+                # Spark MEDIUM sweep #3 (2026-05-26) — bounded-backoff consumer
+                # for delivery.py:_handle_trust_retry_needed. payload carries the
+                # message_id and current attempt; _execute_trust_retry resets the
+                # row to 'accepted', re-runs _deliver_pending_message with the
+                # attempt threaded through, and either delivers, reschedules, or
+                # hits the terminal trust_auto_answer_exhausted branch.
+                from team_agent.messaging.delivery import _execute_trust_retry
+                result = _execute_trust_retry(
+                    workspace, store, event_log, payload,
+                    owner_team_id=row.get("owner_team_id"),
+                )
             else:
                 result = {"ok": False, "error": f"unknown scheduled event kind: {row['kind']}"}
             if not result.get("ok") and row["kind"] == "send":

package/src/team_agent/messaging/send.py

@@ -34,19 +34,10 @@ from pathlib import Path
 from typing import Any
 
 def send_message(
-    workspace: Path,
-    target: str | list[str] | None,
-    content: str,
-    task_id: str | None = None,
-    sender: str = "leader",
-    requires_ack: bool = True,
-    confirm_human: bool = False,
-    wait_visible: bool = True,
-    timeout: float = 30.0,
-    lock_timeout: float = 5.0,
-    watch_result: bool = False,
-    block_until_delivered: bool = True,
-    team: str | None = None,
+    workspace: Path, target: str | list[str] | None, content: str, task_id: str | None = None,
+    sender: str = "leader", requires_ack: bool = True, confirm_human: bool = False,
+    wait_visible: bool = True, timeout: float = 30.0, lock_timeout: float = 5.0,
+    watch_result: bool = False, block_until_delivered: bool = True, team: str | None = None,
 ) -> dict[str, Any]:
     with _runtime_lock(workspace, "send", timeout=lock_timeout):
         return _send_message_unlocked(
@@ -66,18 +57,10 @@ def send_message(
 
 
 def _send_message_unlocked(
-    workspace: Path,
-    target: str | list[str] | None,
-    content: str,
-    task_id: str | None = None,
-    sender: str = "leader",
-    requires_ack: bool = True,
-    confirm_human: bool = False,
-    wait_visible: bool = True,
-    timeout: float = 30.0,
-    watch_result: bool = False,
-    block_until_delivered: bool = True,
-    team: str | None = None,
+    workspace: Path, target: str | list[str] | None, content: str, task_id: str | None = None,
+    sender: str = "leader", requires_ack: bool = True, confirm_human: bool = False,
+    wait_visible: bool = True, timeout: float = 30.0, watch_result: bool = False,
+    block_until_delivered: bool = True, team: str | None = None,
 ) -> dict[str, Any]:
     if team is None:
         ambiguous = ambiguous_team_target_result(load_runtime_state(workspace))
@@ -336,6 +319,8 @@ def _send_single_message_unlocked(
         "submit_verification": delivered_result.get("submit_verification"),
         "turn_verification": delivered_result.get("turn_verification"),
     }
+    result.update({key: delivered_result[key] for key in ("reason", "stage") if delivered_result.get(key)})
+    result.update(_structured_delivery_refusal(delivered_result))
     if delivered_result.get("queued"):
         result["queued"] = True
         result["reason"] = delivered_result.get("reason")
@@ -490,7 +475,7 @@ def _broadcast_targets(state: dict[str, Any], spec: dict[str, Any], sender: str)
 
 
 def _compact_broadcast_delivery(result: dict[str, Any]) -> dict[str, Any]:
-    keys = ["ok", "status", "message_id", "to", "reason", "channel"]
+    keys = ["ok", "status", "message_id", "to", "reason", "channel", "detected", "pane_id", "pane_mode", "pane_capture_tail", "stage", "verification"]
     return {key: result[key] for key in keys if key in result}
 
 
@@ -498,3 +483,13 @@ def _compact_fanout_delivery(result: dict[str, Any]) -> dict[str, Any]:
     compact = _compact_broadcast_delivery(result)
     compact["delivered"] = bool(result.get("submitted") or result.get("visible") or result.get("status") in {"submitted", "visible", "delivered", "acknowledged"})
     return compact
+
+
+def _structured_delivery_refusal(delivered_result: dict[str, Any]) -> dict[str, Any]:
+    attempts = delivered_result.get("paste_attempts")
+    if not isinstance(attempts, list):
+        return {}
+    for attempt in attempts:
+        if isinstance(attempt, dict) and attempt.get("reason") == "recipient_pane_in_non_input_mode":
+            return {key: attempt[key] for key in ("detected", "pane_id", "pane_mode", "pane_capture_tail") if key in attempt}
+    return {}

package/src/team_agent/messaging/tmux_io.py

@@ -20,6 +20,7 @@ from team_agent.messaging.deps import (
 
 from pathlib import Path
 from typing import Any
+from team_agent.messaging.tmux_prompt import detect_non_input_scrollback, non_input_scrollback_window
 
 def _tmux_inject_text(
     target: str,
@@ -28,6 +29,8 @@ def _tmux_inject_text(
     buffer_name: str,
     attempts: int = 3,
     provider: str = "fake",
+    *,
+    bypass_non_input_gate: bool = False,
 ) -> dict[str, Any]:
     token_match = re.search(r"\[team-agent-token:([^\]]+)\]", text)
     token = token_match.group(1) if token_match else ""
@@ -37,15 +40,25 @@ def _tmux_inject_text(
     submit_settle_timeout = _tmux_submit_settle_timeout(text)
     text_bytes = _tmux_text_size(text)
     for attempt in range(1, max(attempts, 1) + 1):
-        prepared = _prepare_tmux_pane_for_input(target)
+        prepared = (
+            {"ok": True, "verification": "non_input_gate_bypassed"}
+            if bypass_non_input_gate
+            else _prepare_tmux_pane_for_input(target)
+        )
         if not prepared["ok"]:
-            attempt_log.append({"attempt": attempt, "visible": False, "verification": prepared["verification"]})
+            attempt_log.append(_prepare_failure_attempt(attempt, prepared))
             return {
                 "ok": False,
+                "status": "failed",
                 "stage": prepared["stage"],
+                "reason": prepared.get("reason"),
                 "error": prepared.get("error"),
                 "attempts": attempt_log,
                 "verification": prepared["verification"],
+                "detected": prepared.get("detected"),
+                "pane_id": prepared.get("pane_id"),
+                "pane_mode": prepared.get("pane_mode"),
+                "pane_capture_tail": prepared.get("pane_capture_tail"),
             }
         baseline = _capture_tmux_pane_text(target)
         if not baseline["ok"]:
@@ -97,6 +110,9 @@ def _tmux_inject_text(
             attempt_entry["buffer_delete_error"] = deleted.get("error")
         if prepared.get("recovered_from_mode"):
             attempt_entry["recovered_from_mode"] = True
+            attempt_entry["recovered_from_pane_mode"] = prepared.get("pane_mode")
+        if prepared.get("warning_event"):
+            attempt_entry["warning_event"] = prepared["warning_event"]
         attempt_log.append(attempt_entry)
         if not visible:
             time.sleep(0.2)
@@ -276,50 +292,164 @@ def _tmux_load_buffer_stdin(buffer_name: str, text: str) -> subprocess.Completed
 
 
 def _prepare_tmux_pane_for_input(target: str) -> dict[str, Any]:
-    mode = run_cmd(["tmux", "display-message", "-p", "-t", target, "#{pane_in_mode}"], timeout=5)
-    if mode.returncode != 0:
+    mode_result = _pane_mode(target)
+    if not mode_result["ok"]:
         return {
             "ok": False,
             "stage": "pane-mode-check",
             "verification": "pane_mode_check_failed",
-            "error": mode.stderr.strip() or "tmux pane mode check failed",
+            "error": mode_result.get("error") or "tmux pane mode check failed",
         }
-    if mode.stdout.strip() != "1":
-        return {"ok": True, "verification": "pane_input_ready"}
-    cancel = run_cmd(["tmux", "send-keys", "-t", target, "-X", "cancel"], timeout=10)
-    if cancel.returncode != 0:
+    capture_result = _pane_capture_tail(target, lines=30)
+    if not capture_result["ok"]:
         return {
             "ok": False,
-            "stage": "pane-mode-cancel",
-            "verification": "pane_mode_cancel_failed",
-            "error": cancel.stderr.strip() or "tmux copy-mode cancel failed",
+            "stage": "pane-tail-capture",
+            "verification": "pane_tail_capture_failed",
+            "error": capture_result.get("error") or "tmux capture-pane failed",
         }
+    pane_mode = _normalize_pane_mode(mode_result.get("pane_mode"))
+    capture_tail = str(capture_result.get("capture") or "")
+    detected = detect_non_input_scrollback(capture_tail)
+    if detected:
+        return _non_input_refusal(target, pane_mode, capture_tail, detected)
+    if not pane_mode:
+        return {"ok": True, "verification": "pane_input_ready"}
+    cancel = _pane_mode_cancel(target, pane_mode)
+    if not cancel["ok"]:
+        return _non_input_refusal(
+            target,
+            pane_mode,
+            capture_tail,
+            f"tmux_{pane_mode}",
+            error=cancel.get("error") or "tmux pane mode cancel failed",
+            verification="pane_mode_cancel_failed",
+            warning_event=cancel.get("warning_event"),
+        )
+    warning_event = cancel.get("warning_event")
     deadline = time.monotonic() + 1.5
     while True:
-        check = run_cmd(["tmux", "display-message", "-p", "-t", target, "#{pane_in_mode}"], timeout=5)
-        if check.returncode != 0:
+        check = _pane_mode(target)
+        if not check["ok"]:
             return {
                 "ok": False,
                 "stage": "pane-mode-check",
                 "verification": "pane_mode_recheck_failed",
-                "error": check.stderr.strip() or "tmux pane mode recheck failed",
+                "error": check.get("error") or "tmux pane mode recheck failed",
             }
-        if check.stdout.strip() != "1":
-            return {"ok": True, "verification": "pane_input_ready_after_mode_cancel", "recovered_from_mode": True}
-        if time.monotonic() >= deadline:
-            return {
-                "ok": False,
-                "stage": "pane-mode-cancel",
-                "verification": "pane_mode_still_active_after_cancel",
-                "error": "tmux pane stayed in copy-mode after cancel",
+        if not _normalize_pane_mode(check.get("pane_mode")):
+            result = {
+                "ok": True,
+                "verification": "pane_input_ready_after_mode_cancel",
+                "recovered_from_mode": True,
+                "pane_mode": pane_mode,
             }
+            if warning_event:
+                result["warning_event"] = warning_event
+            return result
+        if time.monotonic() >= deadline:
+            return _non_input_refusal(
+                target,
+                pane_mode,
+                capture_tail,
+                f"tmux_{pane_mode}",
+                error=f"tmux pane stayed in {pane_mode} after cancel",
+                verification="pane_mode_still_active_after_cancel",
+                warning_event=warning_event,
+            )
         time.sleep(0.1)
 
 
+def _pane_mode(target: str) -> dict[str, Any]:
+    proc = run_cmd(["tmux", "display-message", "-p", "-t", target, "#{pane_mode}"], timeout=5)
+    if proc.returncode != 0:
+        return {"ok": False, "error": proc.stderr.strip() or "tmux pane mode check failed"}
+    return {"ok": True, "pane_mode": proc.stdout.strip()}
+
+
+def _pane_capture_tail(target: str, lines: int = 30) -> dict[str, Any]:
+    capture = run_cmd(["tmux", "capture-pane", "-p", "-S", f"-{lines}", "-t", target], timeout=5)
+    if capture.returncode != 0:
+        return {"ok": False, "capture": "", "error": capture.stderr.strip() or "tmux capture-pane failed"}
+    return {"ok": True, "capture": capture.stdout}
+
+
+def _pane_mode_cancel(target: str, pane_mode: str) -> dict[str, Any]:
+    mode = _normalize_pane_mode(pane_mode)
+    warning_event = None
+    if mode == "copy-mode":
+        args = ["tmux", "send-keys", "-t", target, "-X", "cancel"]
+    elif mode in {"tree-mode", "view-mode"}:
+        args = ["tmux", "send-keys", "-t", target, "q"]
+    elif mode == "client-mode":
+        args = ["tmux", "send-keys", "-t", target, "d"]
+    else:
+        args = ["tmux", "send-keys", "-t", target, "-X", "cancel"]
+        warning_event = "pane_mode_unknown_cancel_attempted"
+    cancel = run_cmd(args, timeout=10)
+    if cancel.returncode != 0:
+        return {
+            "ok": False,
+            "error": cancel.stderr.strip() or f"tmux {mode or 'unknown'} cancel failed",
+            "warning_event": warning_event,
+        }
+    result = {"ok": True, "mode": mode, "args": args}
+    if warning_event:
+        result["warning_event"] = warning_event
+    return result
+
+
+def _normalize_pane_mode(mode: Any) -> str:
+    value = str(mode or "").strip()
+    if value == "0":
+        return ""
+    if value == "1":
+        return "copy-mode"
+    return value
+
+
+def _non_input_refusal(
+    target: str,
+    pane_mode: str,
+    capture_tail: str,
+    detected: str,
+    *,
+    error: str | None = None,
+    verification: str = "recipient_pane_in_non_input_mode",
+    warning_event: str | None = None,
+) -> dict[str, Any]:
+    result = {
+        "ok": False,
+        "status": "failed",
+        "stage": "pre-paste-pane-state",
+        "reason": "recipient_pane_in_non_input_mode",
+        "error": error or "recipient_pane_in_non_input_mode",
+        "verification": verification,
+        "detected": detected,
+        "pane_id": target,
+        "pane_mode": pane_mode,
+        "pane_capture_tail": non_input_scrollback_window(capture_tail) or _last_lines(capture_tail, 10),
+    }
+    if warning_event:
+        result["warning_event"] = warning_event
+    return result
 
 
+def _prepare_failure_attempt(attempt: int, prepared: dict[str, Any]) -> dict[str, Any]:
+    entry = {
+        "attempt": attempt,
+        "visible": False,
+        "verification": prepared["verification"],
+    }
+    for key in ("reason", "detected", "pane_id", "pane_mode", "pane_capture_tail", "warning_event"):
+        if key in prepared:
+            entry[key] = prepared[key]
+    return entry
 
 
+def _last_lines(text: str, count: int) -> str:
+    lines = text.splitlines()
+    return "\n".join(lines[-count:])
 
 
 

package/src/team_agent/messaging/tmux_prompt.py

@@ -12,6 +12,93 @@ from team_agent.messaging.deps import (
 from pathlib import Path
 from typing import Any
 
+
+_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+
+
+def detect_non_input_scrollback(capture_tail: str) -> str | None:
+    nonempty = _non_input_scrollback_lines(capture_tail)
+    tail_text = "\n".join(nonempty)
+    lower = tail_text.lower()
+    stale_before_input = _stale_non_input_before_ready_prompt(nonempty)
+    if re.search(r"do\s+you\s+trust\s+the\s+contents\s+of\s+this\s+directory", lower):
+        if stale_before_input:
+            return None
+        return "codex_trust_prompt"
+    if "press enter to log in" in lower or "press enter to login" in lower:
+        if stale_before_input:
+            return None
+        return "codex_first_run_auth"
+    if "capability may degrade" in lower:
+        if stale_before_input:
+            return None
+        return "codex_compaction_warning"
+    if re.search(r"press\s+(enter|return)\s+to\s+continue", lower):
+        if stale_before_input:
+            return None
+        return "generic_press_enter"
+    if re.search(r"press\s+any\s+key", lower):
+        if stale_before_input:
+            return None
+        return "generic_press_enter"
+    if re.search(r"(\(y/n\)|\([yY]/n\)|\[y/N\]|\[Y/n\]|\[y/n\])", tail_text):
+        if stale_before_input:
+            return None
+        return "y_n_confirm"
+    for first, second in zip(nonempty, nonempty[1:]):
+        if _starts_numbered_choice(first, "1") and _starts_numbered_choice(second, "2"):
+            if stale_before_input:
+                return None
+            return "numbered_menu"
+    if nonempty:
+        last = nonempty[-1]
+        if re.search(r"(^|[\s~/.\w-])[$%]\s*$", last):
+            return "shell_prompt_cli_dead"
+    return None
+
+
+def non_input_scrollback_window(capture_tail: str, limit: int = 15) -> str:
+    return "\n".join(_non_input_scrollback_lines(capture_tail, limit=limit))
+
+
+def _non_input_scrollback_lines(capture_tail: str, limit: int = 15) -> list[str]:
+    lines = [_ANSI_ESCAPE_RE.sub("", line).rstrip() for line in capture_tail.splitlines()]
+    while lines and not lines[-1].strip():
+        lines.pop()
+    return [line for line in lines if line.strip()][-limit:]
+
+
+def _starts_numbered_choice(line: str, number: str) -> bool:
+    return bool(re.match(rf"^\s*(?:[›❯>]\s*)?{number}\.\s+", line))
+
+
+def _stale_non_input_before_ready_prompt(lines: list[str]) -> bool:
+    latest_non_input = -1
+    latest_ready = -1
+    for index, line in enumerate(lines):
+        lower = line.lower()
+        if (
+            "do you trust the contents of this directory" in lower
+            or re.search(r"press\s+(enter|return)\s+to\s+continue", lower)
+            or re.search(r"press\s+any\s+key", lower)
+            or _starts_numbered_choice(line, "1")
+            or _starts_numbered_choice(line, "2")
+        ):
+            latest_non_input = index
+        if _is_input_ready_prompt(line):
+            latest_ready = index
+    return latest_non_input >= 0 and latest_ready > latest_non_input
+
+
+def _is_input_ready_prompt(line: str) -> bool:
+    if _starts_numbered_choice(line, "1") or _starts_numbered_choice(line, "2"):
+        return False
+    value = line.strip()
+    if re.match(r"^[›❯>]\s+\S", value):
+        return True
+    return bool(re.search(r"\b(codex|claude)\s*[>›❯]\s*$", value, re.IGNORECASE))
+
+
 def _enable_codex_fast_mode(session_name: str, window_name: str) -> dict[str, Any]:
     target = f"{session_name}:{window_name}"
     proc = run_cmd(["tmux", "send-keys", "-t", target, "/fast", "Enter"], timeout=10)