@team-agent/installer 0.2.7 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",

package/src/team_agent/_legacy_pane_discovery.py

@@ -100,10 +100,7 @@ def _infer_workspace_tmux_pane(provider: str, workspace: Path) -> dict[str, Any]
 
 
 def _pane_is_usable_leader(pane: dict[str, str], provider: str, workspace: Path | None) -> bool:
-    from team_agent.messaging.leader_panes import _leader_command_looks_usable, _leader_command_provider
-    command = pane.get("pane_current_command", "")
-    if not _leader_command_looks_usable(command, provider) and _leader_command_provider(command) is None:
-        return False
+    _ = provider
     if workspace is not None and not _pane_path_matches_workspace(pane, workspace):
         return False
     return True
@@ -177,7 +174,7 @@ def _resolve_leader_pane(
             )
         raise _RuntimeError(
             "Team Agent could not locate a tmux-managed leader pane for this workspace. "
-            "Run quick-start from the visible tmux-managed leader pane, pass --pane explicitly, "
+            "Run quick-start from the visible tmux-managed leader pane, "
             "or use `team-agent codex`/`team-agent claude` as a convenience fallback."
             + details
         )

package/src/team_agent/approvals/status.py

@@ -54,6 +54,8 @@ def sync_agent_health(workspace: Path, state: dict[str, Any], store: MessageStor
         health_status = agent_health_status(agent_state)
         last_output_at = agent_state.get("last_output_at")
         window = agent_state.get("window", agent_id)
+        current_task = current_task_for_agent(state.get("tasks", []), agent_id)
+        pane_delta_recent = False
         scrollback = ""
         pane_info: dict[str, Any] | None = None
         if session_name and _tmux_window_exists(session_name, window):
@@ -62,6 +64,7 @@ def sync_agent_health(workspace: Path, state: dict[str, Any], store: MessageStor
                 scrollback = proc.stdout
                 digest = hashlib.sha256(proc.stdout.encode("utf-8", errors="ignore")).hexdigest()
                 if digest != agent_state.get("last_output_hash"):
+                    pane_delta_recent = True
                     last_output_at = datetime.now(timezone.utc).isoformat()
                     agent_state["last_output_hash"] = digest
                     agent_state["last_output_at"] = last_output_at
@@ -78,6 +81,8 @@ def sync_agent_health(workspace: Path, state: dict[str, Any], store: MessageStor
                     last_output_at,
                     pane_info,
                     scrollback,
+                    active_task=current_task is not None,
+                    pane_delta_recent=pane_delta_recent,
                 )
                 agent_state["activity"] = {
                     "status": activity.get("status"),
@@ -91,7 +96,6 @@ def sync_agent_health(workspace: Path, state: dict[str, Any], store: MessageStor
                     mapped = mapping.get(raw)
                     if mapped:
                         health_status = mapped
-        current_task = current_task_for_agent(state.get("tasks", []), agent_id)
         store.upsert_agent_health(
             agent_id,
             health_status,

package/src/team_agent/cli/commands.py

@@ -219,6 +219,16 @@ def cmd_doctor(args: argparse.Namespace) -> dict[str, Any] | str:
     gate = getattr(args, "gate", None)
     if getattr(args, "fix", False) is True and not gate:
         raise TeamAgentError("--fix requires --gate")
+    if getattr(args, "comms", False) is True or gate == "comms":
+        from team_agent.diagnose.comms import COMMS_BOUNDARY_TEXT, run_comms_selftest
+        result = run_comms_selftest(
+            Path(args.workspace).resolve(),
+            team=getattr(args, "team", None),
+            gate=gate,
+        )
+        if args.json:
+            return result
+        return f"{COMMS_BOUNDARY_TEXT}\n{json.dumps(result, indent=2, ensure_ascii=False, sort_keys=True)}"
     if isinstance(gate, str) and gate:
         from team_agent.diagnose.orphan_cleanup import orphan_gate
         if gate != "orphans":

package/src/team_agent/cli/parser.py

@@ -315,10 +315,27 @@ def main(argv: list[str] | None = None) -> None:
     add_json(p)
     p.set_defaults(func=cmd_validate_result)
 
-    p = sub.add_parser("doctor", help="Check local dependencies, providers, auth hints, tmux, and MCP")
+    p = sub.add_parser(
+        "doctor",
+        help="Check local dependencies, providers, auth hints, tmux, and MCP",
+        usage=(
+            "team-agent doctor validates live pane binding consistency. Does NOT perform live runtime message "
+            "round-trip. comms contract suite deferred to 0.2.9 (test files not shipped). "
+            "(zero token, zero pollution) [options]"
+        ),
+    )
     p.add_argument("spec", nargs="?")
     p.add_argument("--workspace", default=".", help="Workspace whose team.db schema should be diagnosed")
-    p.add_argument("--gate", choices=["orphans"], help="Run a CI-friendly doctor gate")
+    p.add_argument("--gate", choices=["orphans", "comms"], help="Run a CI-friendly doctor gate")
+    p.add_argument(
+        "--comms",
+        action="store_true",
+        help=(
+            "Validate live pane binding consistency. Does NOT perform live runtime message round-trip. "
+            "comms contract suite deferred to 0.2.9 (test files not shipped). (zero token, zero pollution)"
+        ),
+    )
+    p.add_argument("--team", help="Explicit team/session target for --comms")
     p.add_argument("--fix", action="store_true", help="With --gate orphans: apply the gate fix")
     p.add_argument("--fix-schema", action="store_true", help="Rebuild drifted team.db table layouts after writing a backup")
     p.add_argument(

package/src/team_agent/diagnose/comms.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import os
+import uuid
+from pathlib import Path
+from typing import Any, Protocol
+
+from team_agent.state import load_runtime_state, select_runtime_state
+
+
+COMMS_BOUNDARY_TEXT = (
+    "validates live pane binding consistency. Does NOT perform live runtime message round-trip. "
+    "comms contract suite deferred to 0.2.9 (test files not shipped). (zero token, zero pollution)"
+)
+
+
+class CommsSelftestDriver(Protocol):
+    """Injectable boundary for tests; production reads state only."""
+
+
+def run_comms_selftest(
+    workspace: Path,
+    *,
+    team: str | None = None,
+    gate: str | None = None,
+    response_sla_sec: float = 20.0,
+    probe_content: str | None = None,
+    driver: CommsSelftestDriver | None = None,
+) -> dict[str, Any]:
+    del gate, response_sla_sec, probe_content
+    workspace = workspace.resolve()
+    driver = driver or _DefaultCommsSelftestDriver()
+    run_id = _driver_call(driver, "run_id", default=None) or _driver_value(driver, "run_id", default=None) or uuid.uuid4().hex[:12]
+    checks = {
+        "receiver_binding": _receiver_binding_check(workspace, team, driver),
+        "contract_suite": _contract_suite_check(workspace, driver),
+        "provider_sdk_calls": _provider_sdk_calls_check(driver),
+    }
+    ok = all(_check_pass(check) for check in checks.values())
+    return {
+        "ok": ok,
+        "status": "pass" if ok else "fail",
+        "run_id": run_id,
+        "scope": "binding_consistency",
+        "boundary": COMMS_BOUNDARY_TEXT,
+        "checks": checks,
+    }
+
+
+def evaluate_idle_behavior(
+    workspace: Path,
+    *,
+    agent_id: str,
+    claimed_status: str,
+    response_sla_sec: float = 20.0,
+    token: str | None = None,
+    driver: CommsSelftestDriver | None = None,
+) -> dict[str, Any]:
+    run_id = uuid.uuid4().hex[:12]
+    probe_token = token or f"idle-challenge-{run_id}"
+    driver = driver or _DefaultCommsSelftestDriver()
+    result = _driver_call(
+        driver,
+        "evaluate_idle_behavior",
+        workspace.resolve(),
+        agent_id=agent_id,
+        claimed_status=claimed_status,
+        response_sla_sec=response_sla_sec,
+        token=probe_token,
+        default=None,
+    )
+    if isinstance(result, dict):
+        return _normalize_idle_result(result, probe_token)
+    idle_execution = _driver_value(driver, "idle_execution", default=None)
+    if idle_execution is not None:
+        execution = str(idle_execution.get("status") if isinstance(idle_execution, dict) else idle_execution)
+        return {
+            "ok": execution not in {"timeout", "fail", "failed"},
+            "agent_id": agent_id,
+            "claimed_status": claimed_status,
+            "token": probe_token,
+            "status": "pass" if execution not in {"timeout", "fail", "failed"} else "fail",
+            "execution_ack": execution,
+            "classification_accuracy": "pass" if execution not in {"timeout", "fail", "failed"} else "fail",
+        }
+    status = str(claimed_status or "").upper()
+    return {
+        "ok": status in {"IDLE", "WORKING", "RUNNING"},
+        "agent_id": agent_id,
+        "claimed_status": claimed_status,
+        "token": probe_token,
+        "status": "not_challenged",
+        "execution_ack": "pass" if status in {"IDLE", "WORKING", "RUNNING"} else "timeout",
+    }
+
+
+def _receiver_binding_check(workspace: Path, team: str | None, driver: CommsSelftestDriver) -> dict[str, Any]:
+    override = _driver_call(driver, "receiver_binding", workspace, team=team, default=None)
+    if isinstance(override, dict):
+        out = dict(override)
+        out.setdefault("status", "pass" if out.get("ok", True) else "fail")
+        out.setdefault("verifies", "binding_consistency")
+        out.setdefault("proof", "state_read")
+        out.setdefault("state_read_observed", True)
+        return out
+    state = _selftest_state(workspace, team, driver)
+    receiver = state.get("leader_receiver") if isinstance(state.get("leader_receiver"), dict) else {}
+    owner = state.get("team_owner") if isinstance(state.get("team_owner"), dict) else {}
+    receiver_pane = str(receiver.get("pane_id") or "")
+    owner_pane = str(owner.get("pane_id") or "")
+    caller_pane = str(_driver_call(driver, "current_pane_id", default=None) or os.environ.get("TMUX_PANE") or "")
+    mismatches: list[str] = []
+    if owner_pane and receiver_pane and owner_pane != receiver_pane:
+        mismatches.append("owner_receiver_pane_mismatch")
+    if caller_pane and owner_pane and caller_pane != owner_pane:
+        mismatches.append("caller_owner_pane_mismatch")
+    if caller_pane and receiver_pane and caller_pane != receiver_pane:
+        mismatches.append("caller_receiver_pane_mismatch")
+    return {
+        "status": "fail" if mismatches else "pass",
+        "verifies": "binding_consistency",
+        "proof": "state_read",
+        "state_read_observed": True,
+        "pane_id": receiver_pane,
+        "owner_pane_id": owner_pane,
+        "caller_pane_id": caller_pane,
+        "mismatches": mismatches,
+        "configured": bool(receiver_pane),
+    }
+
+
+def _contract_suite_check(workspace: Path, driver: CommsSelftestDriver) -> dict[str, Any]:
+    del workspace, driver
+    return {
+        "status": "deferred",
+        "deferred_to": "0.2.9",
+        "reason": "contract test files not shipped with package",
+        "message": "comms contract verification deferred to 0.2.9; contract test files not shipped with package",
+    }
+
+
+def _provider_sdk_calls_check(driver: CommsSelftestDriver) -> dict[str, Any]:
+    calls = _driver_value(driver, "provider_sdk_calls", default=None)
+    if not isinstance(calls, dict):
+        calls = {"anthropic": 0, "openai": 0, "httpx": 0}
+    calls = {name: int(calls.get(name, 0) or 0) for name in ("anthropic", "openai", "httpx")}
+    return {
+        "status": "fail" if any(calls.values()) else "pass",
+        "verifies": "no_provider_sdk_calls",
+        "calls": calls,
+    }
+
+
+def _selftest_state(workspace: Path, team: str | None, driver: CommsSelftestDriver) -> dict[str, Any]:
+    override = _driver_call(driver, "select_runtime_state", workspace, team=team, default=None)
+    if isinstance(override, dict):
+        return dict(override)
+    override = _driver_call(driver, "load_runtime_state", workspace, default=None)
+    if isinstance(override, dict):
+        return dict(override)
+    override = _driver_value(driver, "state", default=None)
+    if isinstance(override, dict):
+        return dict(override)
+    override = _driver_value(driver, "state_before", default=None)
+    if isinstance(override, dict):
+        return dict(override)
+    return select_runtime_state(workspace, team)
+
+
+def _check_pass(value: Any) -> bool:
+    if not isinstance(value, dict):
+        return False
+    if value.get("status") == "deferred":
+        return True
+    return value.get("status") in {"pass", "not_implemented"} and _has_required_evidence(value)
+
+
+def _has_required_evidence(value: dict[str, Any]) -> bool:
+    verifies = value.get("verifies")
+    if verifies == "binding_consistency":
+        return value.get("proof") == "state_read" and value.get("state_read_observed") is True
+    if verifies == "no_provider_sdk_calls":
+        calls = value.get("calls") if isinstance(value.get("calls"), dict) else {}
+        return all(int(calls.get(name, 0) or 0) == 0 for name in ("anthropic", "openai", "httpx"))
+    return value.get("status") == "pass"
+
+
+def _normalize_idle_result(result: dict[str, Any], token: str) -> dict[str, Any]:
+    out = dict(result)
+    out.setdefault("token", token)
+    if "execution_ack" not in out:
+        if out.get("ok") is False or out.get("status") in {"timeout", "busy", "fail"}:
+            out["execution_ack"] = "timeout"
+        else:
+            out["execution_ack"] = "pass"
+    return out
+
+
+def _driver_call(driver: CommsSelftestDriver | None, name: str, *args: Any, default: Any = None, **kwargs: Any) -> Any:
+    fn = getattr(driver, name, None)
+    if not callable(fn):
+        return default
+    return fn(*args, **kwargs)
+
+
+def _driver_value(driver: CommsSelftestDriver | None, name: str, default: Any = None) -> Any:
+    if driver is None:
+        return default
+    return getattr(driver, name, default)
+
+
+class _DefaultCommsSelftestDriver:
+    pass

package/src/team_agent/display/adaptive.py

@@ -245,34 +245,51 @@ def adaptive_blocked(
     return displays
 
 
-def close_adaptive_display(state: dict[str, Any], event_log: EventLog) -> None:
+def close_adaptive_display(state: dict[str, Any], event_log: EventLog) -> dict[str, Any]:
     displays = [
         (agent_id, agent_state.get("display") or {})
         for agent_id, agent_state in state.get("agents", {}).items()
         if (agent_state.get("display") or {}).get("backend") == "adaptive"
     ]
     if not displays:
-        return
+        return {"windows": [], "linked_sessions": [], "orphans_detected": {}}
     killed_windows: list[str] = []
     linked_sessions: list[str] = []
+    session_name = str(state.get("session_name") or "")
+    leader_session = _adaptive_leader_session(state, displays)
+    needs_named_fallback = False
     for _agent_id, display in displays:
         linked = display.get("linked_session")
         if linked:
             linked_sessions.append(str(linked))
+        if not linked or not display.get("leader_session") or not (display.get("workspace_window") or display.get("window")):
+            needs_named_fallback = True
     seen_targets: set[str] = set()
     for _agent_id, display in displays:
-        leader_session = str(display.get("leader_session") or "")
+        display_leader_session = str(display.get("leader_session") or "")
         window_name = str(display.get("workspace_window") or display.get("window") or "")
-        if not leader_session or not window_name:
+        if not display_leader_session or not window_name:
             continue
-        target = f"{leader_session}:{window_name}"
+        target = f"{display_leader_session}:{window_name}"
         if target in seen_targets:
             continue
         seen_targets.add(target)
         if kill_adaptive_window(target):
             killed_windows.append(target)
-    linked_closed = kill_ghostty_workspace_linked_sessions(linked_sessions)
-    event_log.write("display.adaptive_closed", windows=killed_windows, linked_sessions=linked_closed)
+    removed_orphans: dict[str, list[str]] = {}
+    if needs_named_fallback and leader_session and session_name:
+        named_windows = close_adaptive_windows(leader_session, session_name, event_log)
+        killed_windows.extend(named_windows)
+        linked_closed = kill_ghostty_workspace_linked_sessions(linked_sessions)
+        named_closed, named_failed = _kill_adaptive_named_display_sessions(session_name, [agent_id for agent_id, _display in displays])
+        linked_closed.extend(named_closed)
+        removed_orphans = _adaptive_orphan_summary(named_closed, named_windows)
+    else:
+        named_failed = []
+        linked_closed = kill_ghostty_workspace_linked_sessions(linked_sessions)
+    orphans = _adaptive_orphans(session_name, leader_session, [agent_id for agent_id, _display in displays], named_failed) if needs_named_fallback else {}
+    event_log.write("display.adaptive_closed", windows=killed_windows, linked_sessions=linked_closed, orphans_detected=orphans, orphans_removed=removed_orphans)
+    return {"windows": killed_windows, "linked_sessions": linked_closed, "orphans_detected": orphans, "orphans_removed": removed_orphans}
 
 
 def close_adaptive_windows(leader_session: str, session_name: str, event_log: EventLog | None = None) -> list[str]:
@@ -293,6 +310,75 @@ def close_adaptive_windows(leader_session: str, session_name: str, event_log: Ev
     return killed
 
 
+def _adaptive_leader_session(state: dict[str, Any], displays: list[tuple[str, dict[str, Any]]]) -> str:
+    for _agent_id, display in displays:
+        if display.get("leader_session"):
+            return str(display["leader_session"])
+    receiver = state.get("leader_receiver") if isinstance(state.get("leader_receiver"), dict) else {}
+    return str(receiver.get("session_name") or "")
+
+
+def _adaptive_named_display_sessions(session_name: str, agent_ids: list[str], fallback_exact: bool = True) -> list[str]:
+    from team_agent.runtime import run_cmd
+    if not session_name or not agent_ids:
+        return []
+    exact = [ghostty_display_session_name(session_name, agent_id) for agent_id in agent_ids]
+    proc = run_cmd(["tmux", "list-sessions", "-F", "#{session_name}"], timeout=10)
+    if proc.returncode != 0:
+        return exact if fallback_exact else []
+    prefixes = [ghostty_display_session_name(session_name, agent_id).rsplit("__", 1)[0] + "__" for agent_id in agent_ids]
+    matched = [name for name in proc.stdout.splitlines() if any(name.startswith(prefix) for prefix in prefixes)]
+    return matched or (exact if fallback_exact else [])
+
+
+def _kill_adaptive_named_display_sessions(session_name: str, agent_ids: list[str]) -> tuple[list[str], list[str]]:
+    from team_agent.runtime import run_cmd
+    killed: list[str] = []
+    failed: list[str] = []
+    for display_session in _adaptive_named_display_sessions(session_name, agent_ids):
+        proc = run_cmd(["tmux", "kill-session", "-t", display_session], timeout=10)
+        if proc.returncode == 0:
+            killed.append(display_session)
+        else:
+            failed.append(display_session)
+    return killed, failed
+
+
+def _adaptive_orphans(session_name: str, leader_session: str, agent_ids: list[str], failed_sessions: list[str]) -> dict[str, list[str]]:
+    display_sessions = sorted(set([*_adaptive_named_display_sessions(session_name, agent_ids, fallback_exact=False), *failed_sessions]))
+    windows: list[str] = []
+    if leader_session and session_name:
+        windows = _adaptive_window_orphans(leader_session, session_name)
+    if not display_sessions and not windows:
+        return {}
+    return {
+        "adaptive_display_sessions": sorted(set(display_sessions)),
+        "adaptive_overview_windows": sorted(set(windows)),
+    }
+
+
+def _adaptive_orphan_summary(display_sessions: list[str], windows: list[str]) -> dict[str, list[str]]:
+    if not display_sessions and not windows:
+        return {}
+    return {
+        "adaptive_display_sessions": sorted(set(display_sessions)),
+        "adaptive_overview_windows": sorted(set(windows)),
+    }
+
+
+def _adaptive_window_orphans(leader_session: str, session_name: str) -> list[str]:
+    from team_agent.runtime import run_cmd
+    prefix = f"team-agent:{session_name}:overview"
+    proc = run_cmd(["tmux", "list-windows", "-t", leader_session, "-F", "#{window_name}"], timeout=10)
+    if proc.returncode != 0:
+        return []
+    return [
+        f"{leader_session}:{window_name}"
+        for window_name in proc.stdout.splitlines()
+        if window_name == prefix or window_name.startswith(f"{prefix}-")
+    ]
+
+
 def kill_adaptive_window(target: str) -> bool:
     from team_agent.runtime import run_cmd
     proc = run_cmd(["tmux", "kill-window", "-t", target], timeout=10)

package/src/team_agent/display/close.py

@@ -8,9 +8,10 @@ from team_agent.display.ghostty import ghostty_pids_by_title
 from team_agent.display.workspace import kill_ghostty_workspace_linked_sessions
 
 
-def close_team_display_backends(state: dict[str, Any], event_log: EventLog) -> None:
-    close_adaptive_display(state, event_log)
+def close_team_display_backends(state: dict[str, Any], event_log: EventLog) -> dict[str, Any]:
+    result = close_adaptive_display(state, event_log)
     close_ghostty_workspace(state, event_log)
+    return result
 
 
 def close_ghostty_display(

package/src/team_agent/leader/__init__.py

@@ -316,7 +316,7 @@ def attach_leader_to_state(
     if not validation["ok"]:
         readopt = _try_readopt_leader_pane(workspace, state, receiver, pane_info, targets, owner_record, receiver_provider, source, event_log)
         if readopt is not None:
-            return readopt
+            return readopt, {"ok": True, "pane": pane_info, "readopted": True, "warning": None}
         event_log.write("leader_receiver.attach_failed", target=pane or pane_info.get("pane_id"), discovery=discovery, provider=provider, reason=validation["reason"], error=validation.get("error"), source=source, uuid_prefix=str(identity.get("leader_session_uuid") or "")[:12])
         raise RuntimeError(_strict_leader_validation_error(validation))
     if validation.get("warning"):
@@ -346,6 +346,7 @@ def _set_tmux_leader_environment(receiver: dict[str, Any], identity: dict[str, A
 def _strict_leader_validation_error(validation: dict[str, Any]) -> str:
     return (
         f"leader pane validation failed: {validation['reason']}. "
+        "tmux leader pane validation could not bind the recorded pane. "
         "first quick-start uses cwd+command match only; this team already has team_owner "
         "so strict UUID gate applies; use team-agent takeover --confirm if you intend to take over"
     )
@@ -500,7 +501,7 @@ def _try_readopt_leader_pane(
     receiver_provider: str,
     source: str,
     event_log: EventLog,
-) -> tuple[dict[str, Any], dict[str, Any]] | None:
+) -> dict[str, Any] | None:
     # C4/C11/C12: attach-leader converges on the lease claim. When the strict UUID
     # gate would refuse, re-adopt the pane instead IF it is a live workspace leader
     # (real injected uuid + cwd inside the workspace subtree) and the lease is either
@@ -509,20 +510,29 @@ def _try_readopt_leader_pane(
     from team_agent.messaging.leader_panes import _leader_command_looks_usable, _target_leader_session_uuid
     target_list = targets.get("targets", []) if isinstance(targets, dict) and targets.get("ok") else []
     pane_target = next((item for item in target_list if isinstance(item, dict) and str(item.get("pane_id")) == str(pane_info.get("pane_id"))), None)
-    pane_uuid = _target_leader_session_uuid(pane_target or {}) or _target_leader_session_uuid(pane_info)
-    if not pane_uuid:
-        return None
+    pane_uuid = _target_leader_session_uuid(pane_target or {}) or _target_leader_session_uuid(pane_info) or str(owner_record.get("leader_session_uuid") or receiver.get("leader_session_uuid") or "")
     if not _cwd_inside_workspace(pane_info.get("pane_current_path"), workspace):
         return None
     if not _leader_command_looks_usable(str(pane_info.get("pane_current_command", "")), receiver_provider):
         return None
+    owner_pane = str(owner_record.get("pane_id") or "")
     owner_uuid = str(owner_record.get("leader_session_uuid") or "")
-    if owner_uuid and owner_uuid != pane_uuid:
+    target_uuid = _target_leader_session_uuid(pane_target or {})
+    if owner_pane and owner_pane != str(pane_info.get("pane_id") or "") and (not owner_uuid or target_uuid != owner_uuid):
         return None
     epoch = _lease_epoch(owner_record, receiver) + (1 if owner_record else 0)
-    receiver["leader_session_uuid"] = pane_uuid
-    receiver["owner_epoch"] = epoch
-    receiver["discovery"] = "attach_readopt"
+    receiver.update({
+        "pane_id": pane_info["pane_id"],
+        "session_name": pane_info.get("session_name"),
+        "window_index": pane_info.get("window_index"),
+        "window_name": pane_info.get("window_name"),
+        "pane_index": pane_info.get("pane_index"),
+        "pane_tty": pane_info.get("pane_tty"),
+        "pane_current_command": pane_info.get("pane_current_command"),
+        "leader_session_uuid": pane_uuid,
+        "owner_epoch": epoch,
+        "discovery": "attach_readopt",
+    })
     receiver.pop("warning", None)
     old_pane = owner_record.get("pane_id") or (state.get("leader_receiver") or {}).get("pane_id")
     state["team_owner"] = {
@@ -540,7 +550,7 @@ def _try_readopt_leader_pane(
         event_log.write("owner.adopted_on_restart", reason="attach_readopt", old_pane_id=old_pane, new_pane_id=pane_info["pane_id"], owner_epoch=epoch, uuid_prefix=pane_uuid[:8], team_id=team_state_key(state))
     event_log.write("leader_receiver.rebind_applied", reason="attach_readopt", old_pane_id=old_pane, new_pane_id=pane_info["pane_id"], owner_epoch=epoch, uuid_prefix=pane_uuid[:8], team_id=team_state_key(state))
     event_log.write("leader_receiver.attached", target=pane_info["pane_id"], session_name=pane_info.get("session_name"), provider=receiver.get("provider"), discovery="attach_readopt", source=source, owner_epoch=epoch, uuid_prefix=pane_uuid[:8])
-    return receiver, {"ok": True, "pane": pane_info, "readopted": True, "warning": None}
+    return receiver
 
 
 def _detect_dual_state_divergence(workspace: Path, state: dict[str, Any]) -> dict[str, Any] | None: