@team-agent/installer 0.2.1 → 0.2.2

package/src/team_agent/messaging/leader.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import hashlib
+
 from team_agent.messaging.deps import (
     EventLog,
     MessageStore,
@@ -10,8 +12,10 @@ from team_agent.messaging.deps import (
     _validate_leader_receiver,
     core_render_message,
     json,
+    os,
     runtime_dir,
     save_runtime_state,
+    team_state_key,
     time,
 )
 
@@ -49,6 +53,19 @@ def _leader_inbox_path(workspace: Path) -> Path:
     return runtime_dir(workspace) / "leader-inbox.log"
 
 
+def _extract_result_id_from_content(content: str) -> str | None:
+    """Stage 12: result-notification messages embed a `Result id: <id>` line; the gate
+    parses it from content so callers that did NOT plumb the result_id kwarg through
+    still consult the dedupe gate. Format mirrors _format_report_result_notification and
+    format_result_watcher_notification."""
+    if not content:
+        return None
+    for line in content.splitlines():
+        if line.startswith("Result id: "):
+            return line.removeprefix("Result id: ").strip() or None
+    return None
+
+
 def _send_to_leader_receiver(
     workspace: Path,
     state: dict[str, Any],
@@ -58,6 +75,8 @@ def _send_to_leader_receiver(
     sender: str,
     requires_ack: bool,
     event_log: EventLog,
+    *,
+    result_id: str | None = None,
 ) -> dict[str, Any]:
     store = MessageStore(workspace)
     message_id = store.create_message(task_id, sender, leader_id, content, requires_ack=False)
@@ -94,10 +113,30 @@ def _send_to_leader_receiver(
             error="No direct leader tmux pane is attached. Run team-agent attach-leader.",
         )
 
-    validation = _validate_leader_receiver(receiver)
+    owner_identity = state.get("team_owner") or None
+    side_pane_refusal = _side_pane_owner_refusal(state, owner_identity)
+    if side_pane_refusal:
+        event_log.write("leader_receiver.side_pane_refused", **side_pane_refusal)
+        return {
+            "ok": False,
+            "message_id": message_id,
+            "status": "refused",
+            "to": leader_id,
+            "channel": "direct_tmux",
+            **side_pane_refusal,
+        }
+    receiver_for_validation = dict(receiver)
+    if owner_identity and owner_identity.get("leader_session_uuid") and not receiver_for_validation.get("leader_session_uuid"):
+        receiver_for_validation["leader_session_uuid"] = owner_identity["leader_session_uuid"]
+    validation = _validate_leader_receiver(receiver_for_validation)
     if not validation["ok"]:
-        owner_identity = state.get("team_owner") or None
-        rediscovery = _rediscover_leader_receiver(receiver, event_log, owner_identity)
+        rediscovery = _rediscover_leader_receiver(
+            receiver_for_validation,
+            event_log,
+            owner_identity,
+            invalidation_reason=validation.get("reason"),
+            team_id=team_state_key(state),
+        )
         if rediscovery.get("status") == "updated":
             state["leader_receiver"].update(rediscovery["receiver"])
             receiver = state["leader_receiver"]
@@ -111,7 +150,7 @@ def _send_to_leader_receiver(
                 payload,
                 event_log,
                 reason="ambiguous",
-                error="multiple possible leader panes found; rerun team-agent attach-leader --pane <pane_id>",
+                error="multiple possible leader panes found; run team-agent claim-leader --confirm from the intended pane",
                 message_status="ambiguous",
             )
     if not validation["ok"]:
@@ -128,6 +167,69 @@ def _send_to_leader_receiver(
     state["leader_receiver"].update(validation["pane"])
     submit_key, submit_reason = _choose_leader_submit_key(receiver.get("provider", "codex"), validation.get("capture", ""))
     target = receiver["pane_id"]
+    # Stage 12 (Gap 26 ∩ Gap 32 roundtable 2026-05-26) — injection-boundary dedupe gate.
+    # Result-notification injections route through claim_leader_notification_delivery; the
+    # gate suppresses a second inject for the same (result_id, leader_session_uuid).
+    # Non-result messages (peer mirror, idle reminder, ambiguous-prompt) lack a "Result id:"
+    # line in their text and bypass the gate.
+    effective_result_id = result_id or _extract_result_id_from_content(content)
+    leader_uuid_for_gate = str(
+        (state.get("team_owner") or {}).get("leader_session_uuid")
+        or (state.get("leader_receiver") or {}).get("leader_session_uuid")
+        or ""
+    )
+    if effective_result_id and leader_uuid_for_gate:
+        from team_agent.message_store.leader_notification_log import claim_leader_notification_delivery
+        envelope_hash = hashlib.sha256(content.encode("utf-8", errors="ignore")).hexdigest()[:16]
+        claim = claim_leader_notification_delivery(
+            store,
+            result_id=effective_result_id,
+            leader_session_uuid=leader_uuid_for_gate,
+            proposed_message_id=message_id,
+            envelope_hash=envelope_hash,
+            owner_team_id=team_state_key(state),
+            pane_id=target,
+        )
+        if claim["status"] == "already_notified_by":
+            prev_msg = claim.get("notified_message_id")
+            prev_hash = claim.get("envelope_content_hash")
+            if envelope_hash == prev_hash:
+                event_log.write(
+                    "leader_notification.dedupe_skip",
+                    result_id=effective_result_id,
+                    leader_session_uuid=leader_uuid_for_gate,
+                    prev_message_id=prev_msg,
+                    this_message_id=message_id,
+                    prev_ts=claim.get("notified_at"),
+                    pane_id=target,
+                    team_id=team_state_key(state),
+                )
+            else:
+                event_log.write(
+                    "leader_notification.legitimate_duplicate_suspected",
+                    result_id=effective_result_id,
+                    leader_session_uuid=leader_uuid_for_gate,
+                    prev_message_id=prev_msg,
+                    this_message_id=message_id,
+                    prev_envelope_hash=prev_hash,
+                    this_envelope_hash=envelope_hash,
+                    pane_id=target,
+                    team_id=team_state_key(state),
+                )
+            store.mark(message_id, "submitted", "dedupe_suppressed_by_leader_notification_log")
+            save_runtime_state(workspace, state)
+            return {
+                "ok": True,
+                "message_id": message_id,
+                "status": "submitted",
+                "to": leader_id,
+                "channel": "direct_tmux",
+                "leader_receiver": state["leader_receiver"],
+                "visible": False,
+                "submitted": False,
+                "deduped": True,
+                "canonical_message_id": prev_msg,
+            }
     event_log.write(
         "leader_receiver.deliver_attempt",
         message_id=message_id,
@@ -139,6 +241,8 @@ def _send_to_leader_receiver(
         visible_token=rendered.get("token"),
         payload=payload,
         warning=validation.get("warning"),
+        result_id=effective_result_id,
+        leader_session_uuid=leader_uuid_for_gate or None,
     )
     injection = _tmux_inject_text(
         target,
@@ -201,6 +305,64 @@ def _send_to_leader_receiver(
     )
 
 
+def _side_pane_owner_refusal(state: dict[str, Any], owner_identity: dict[str, Any] | None) -> dict[str, Any] | None:
+    owner_uuid = str((owner_identity or {}).get("leader_session_uuid") or "")
+    caller_uuid = os.environ.get("TEAM_AGENT_LEADER_SESSION_UUID") or os.environ.get("TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE") or ""
+    if not owner_uuid or not caller_uuid or caller_uuid == owner_uuid:
+        return None
+    bound_pane = (state.get("leader_receiver") or {}).get("pane_id") or (owner_identity or {}).get("pane_id")
+    team_id = team_state_key(state)
+    return {
+        "reason": "team_owner_mismatch",
+        "error": (
+            f"This workspace's team `{team_id}` is already bound to pane `{bound_pane}`. "
+            "To work in this window either start a new team with a different team_id, operate through the bound pane, "
+            "or run `team-agent claim-leader --confirm` only if you intend to forcibly take over."
+        ),
+        "bound_pane_id": bound_pane,
+        "caller_uuid_prefix": caller_uuid[:8],
+        "uuid_prefix": owner_uuid[:8],
+        "action": "team-agent claim-leader --confirm",
+    }
+
+
+def claim_leader_receiver(
+    workspace: Path,
+    state: dict[str, Any],
+    candidate: dict[str, Any],
+    event_log: EventLog,
+    *,
+    confirm: bool,
+    expected_epoch: int | None = None,
+) -> dict[str, Any]:
+    from team_agent.messaging.leader_panes import _leader_command_looks_usable, _receiver_from_target, _target_matches_owner_identity, _uuid_prefix
+    if not confirm:
+        return {"ok": False, "status": "refused", "reason": "confirm_required", "action": "team-agent claim-leader --confirm"}
+    owner = state.setdefault("team_owner", {})
+    receiver = state.get("leader_receiver") or {}
+    current_epoch = int(owner.get("owner_epoch") or receiver.get("owner_epoch") or 0)
+    if expected_epoch is not None and current_epoch != expected_epoch:
+        event_log.write("leader_receiver.claim_refused", reason="owner_epoch_advanced", owner_epoch=current_epoch, bound_pane_id=receiver.get("pane_id"))
+        return {"ok": False, "status": "refused", "reason": "owner_epoch_advanced", "owner_epoch": current_epoch, "bound_pane_id": receiver.get("pane_id")}
+    if receiver.get("pane_id") == candidate.get("pane_id"):
+        return {"ok": True, "status": "already_bound", "leader_receiver": receiver, "owner_epoch": current_epoch}
+    if not _target_matches_owner_identity(candidate, owner):
+        event_log.write("leader_receiver.claim_refused", reason="uuid_mismatch", candidate_pane_id=candidate.get("pane_id"))
+        return {"ok": False, "status": "refused", "reason": "uuid_mismatch"}
+    provider = str(candidate.get("provider") or receiver.get("provider") or "codex")
+    if not _leader_command_looks_usable(str(candidate.get("pane_current_command", "")), provider):
+        return {"ok": False, "status": "refused", "reason": "wrong_command", "candidate_pane_id": candidate.get("pane_id")}
+    next_epoch = current_epoch + 1
+    new_receiver = _receiver_from_target(candidate, provider, owner.get("leader_session_uuid"), next_epoch)
+    owner["owner_epoch"] = next_epoch
+    state["leader_receiver"] = new_receiver
+    from team_agent.runtime import _runtime_lock, save_runtime_state
+    with _runtime_lock(workspace, "leader_receiver"):
+        save_runtime_state(workspace, state)
+    event_log.write("leader_receiver.claimed", pane_id=new_receiver["pane_id"], owner_epoch=next_epoch, uuid_prefix=_uuid_prefix(owner))
+    return {"ok": True, "status": "claimed", "leader_receiver": new_receiver, "owner_epoch": next_epoch}
+
+
 def _fail_leader_delivery(
     workspace: Path,
     state: dict[str, Any],
@@ -310,8 +472,6 @@ def _format_team_agent_message(payload: dict[str, Any]) -> str:
 
 
 
-
-
 
 
 

package/src/team_agent/messaging/leader_panes.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import hashlib
+
 from team_agent.messaging.deps import (
     EventLog,
     RuntimeError,
@@ -9,6 +11,7 @@ from team_agent.messaging.deps import (
     _tmux_current_client_pane_info as _runtime_tmux_current_client_pane_info,
     _tmux_list_panes as _runtime_tmux_list_panes,
     _tmux_pane_info as _runtime_tmux_pane_info,
+    _tmux_inject_text,
     core_list_targets,
     datetime,
     os,
@@ -20,6 +23,8 @@ from team_agent.messaging.deps import (
 from pathlib import Path
 from typing import Any
 
+_AMBIGUOUS_DEBOUNCE_SECONDS = 60
+
 def _resolve_leader_pane(
     pane: str | None,
     provider: str,
@@ -208,17 +213,40 @@ def _target_fingerprint(pane_info: dict[str, Any]) -> str:
     )
 
 
+def is_bound_pane_still_valid(state: dict[str, Any], store: Any | None = None) -> dict[str, Any]:
+    receiver = dict(state.get("leader_receiver") or {})
+    owner = state.get("team_owner") if isinstance(state.get("team_owner"), dict) else {}
+    if owner and owner.get("leader_session_uuid") and not receiver.get("leader_session_uuid"):
+        receiver["leader_session_uuid"] = owner["leader_session_uuid"]
+    return _validate_leader_receiver(receiver)
+
+
 def _rediscover_leader_receiver(
     receiver: dict[str, Any],
     event_log: EventLog,
     owner_identity: dict[str, Any] | None = None,
+    invalidation_reason: str | None = None,
+    team_id: str | None = None,
 ) -> dict[str, Any]:
     provider = str(receiver.get("provider") or "codex")
-    if provider != "codex":
-        return {"status": "missing", "reason": "rediscovery_only_for_codex"}
+    if provider == "fake":
+        return {"status": "missing", "reason": "rediscovery_not_supported_for_fake"}
     targets = core_list_targets()
     if not targets.get("ok"):
         event_log.write("leader_receiver.rediscover_failed", provider=provider, error=targets.get("error"))
+        # Stage 15 CI fix: when the tmux target scan itself fails (no server, no daemon,
+        # CI env without tmux), the caller has no way to recover unless we also emit
+        # rebind_required. Without this, _refresh_leader_receiver_or_flag_rebind silently
+        # returns and report_result queues against the stale pane with zero audit signal.
+        event_log.write(
+            "leader_receiver.rebind_required",
+            old_pane_id=receiver.get("pane_id"),
+            reason=invalidation_reason,
+            provider=provider,
+            team_id=team_id,
+            rediscovery_status="failed",
+            error=targets.get("error"),
+        )
         return {"status": "failed", "error": targets.get("error")}
     candidates = [
         target
@@ -228,16 +256,26 @@ def _rediscover_leader_receiver(
     if owner_identity:
         owner_candidates = [target for target in candidates if _target_matches_owner_identity(target, owner_identity)]
         if len(owner_candidates) == 1:
-            return _rediscovered_receiver(receiver, provider, owner_candidates[0], event_log, owner_identity)
+            return _rediscovered_receiver(receiver, provider, owner_candidates[0], event_log, owner_identity, invalidation_reason)
         if len(owner_candidates) > 1:
+            incident = _broadcast_ambiguous_candidates(
+                receiver,
+                provider,
+                owner_candidates,
+                event_log,
+                owner_identity,
+                team_id,
+            )
             event_log.write(
                 "leader_receiver.rediscover_ambiguous",
                 provider=provider,
                 old_target=receiver.get("pane_id"),
                 candidates=[target.get("pane_id") for target in owner_candidates],
                 owner_identity=owner_identity,
+                incident_id=incident.get("incident_id"),
+                deduped=incident.get("deduped"),
             )
-            return {"status": "ambiguous", "candidates": owner_candidates, "owner_identity": owner_identity}
+            return {"status": "ambiguous", "candidates": owner_candidates, "owner_identity": owner_identity, **incident}
         event_log.write(
             "leader_receiver.rediscover_missing",
             provider=provider,
@@ -245,9 +283,19 @@ def _rediscover_leader_receiver(
             owner_identity=owner_identity,
             candidate_count=len(candidates),
         )
+        event_log.write(
+            "leader_receiver.rebind_required",
+            old_pane_id=receiver.get("pane_id"),
+            reason=invalidation_reason,
+            provider=provider,
+            team_id=team_id,
+            uuid_prefix=_uuid_prefix(owner_identity),
+            owner_identity=owner_identity,
+            recovery_action="open the owning leader pane or run team-agent claim-leader --confirm from a matching pane",
+        )
         return {"status": "missing", "owner_identity": owner_identity}
     if len(candidates) == 1:
-        return _rediscovered_receiver(receiver, provider, candidates[0], event_log, None)
+        return _rediscovered_receiver(receiver, provider, candidates[0], event_log, None, invalidation_reason)
     if len(candidates) > 1:
         event_log.write(
             "leader_receiver.rediscover_ambiguous",
@@ -255,12 +303,19 @@ def _rediscover_leader_receiver(
             old_target=receiver.get("pane_id"),
             candidates=[target.get("pane_id") for target in candidates],
         )
+        event_log.write("leader_receiver.rebind_required", old_pane_id=receiver.get("pane_id"), reason=invalidation_reason, provider=provider, team_id=team_id, rediscovery_status="ambiguous")
         return {"status": "ambiguous", "candidates": candidates}
     event_log.write("leader_receiver.rediscover_missing", provider=provider, old_target=receiver.get("pane_id"))
+    event_log.write("leader_receiver.rebind_required", old_pane_id=receiver.get("pane_id"), reason=invalidation_reason, provider=provider, team_id=team_id, rediscovery_status="missing")
     return {"status": "missing"}
 
 
 def _target_matches_owner_identity(target: dict[str, Any], owner_identity: dict[str, Any]) -> bool:
+    expected_uuid = owner_identity.get("leader_session_uuid")
+    if expected_uuid:
+        actual_uuid = _target_leader_session_uuid(target)
+        if actual_uuid:
+            return actual_uuid == expected_uuid
     env = target.get("leader_env") if isinstance(target.get("leader_env"), dict) else {}
     return (
         env.get("TEAM_AGENT_LEADER_PANE_ID") == (owner_identity.get("pane_id") or "")
@@ -269,14 +324,31 @@ def _target_matches_owner_identity(target: dict[str, Any], owner_identity: dict[
     )
 
 
-def _rediscovered_receiver(
-    receiver: dict[str, Any],
-    provider: str,
-    target: dict[str, Any],
-    event_log: EventLog,
-    owner_identity: dict[str, Any] | None,
-) -> dict[str, Any]:
-    updated = {
+def _target_leader_session_uuid(target: dict[str, Any]) -> str:
+    env = target.get("leader_env") if isinstance(target.get("leader_env"), dict) else {}
+    return str(target.get("leader_session_uuid") or env.get("TEAM_AGENT_LEADER_SESSION_UUID") or "")
+
+
+def _leader_uuid_for_bound_pane(receiver: dict[str, Any], pane_info: dict[str, Any]) -> str:
+    direct = _target_leader_session_uuid(pane_info) or _target_leader_session_uuid(receiver)
+    if direct:
+        return direct
+    targets = core_list_targets()
+    if not targets.get("ok"):
+        return ""
+    pane_id = pane_info.get("pane_id")
+    for target in targets.get("targets", []):
+        if target.get("pane_id") == pane_id:
+            return _target_leader_session_uuid(target)
+    return ""
+
+
+def _uuid_prefix(owner_identity: dict[str, Any] | None) -> str:
+    return str((owner_identity or {}).get("leader_session_uuid") or "")[:8]
+
+
+def _receiver_from_target(target: dict[str, Any], provider: str, leader_uuid: str | None, owner_epoch: int | None = None) -> dict[str, Any]:
+    receiver = {
         "mode": "direct_tmux",
         "status": "attached",
         "provider": provider,
@@ -289,8 +361,83 @@ def _rediscovered_receiver(
         "pane_current_command": target["pane_current_command"],
         "fingerprint": target.get("fingerprint") or _target_fingerprint(target),
         "attached_at": datetime.now(timezone.utc).isoformat(),
-        "discovery": "stale_rediscovery_owner_identity" if owner_identity else "stale_rediscovery_unique_candidate",
     }
+    if leader_uuid:
+        receiver["leader_session_uuid"] = leader_uuid
+    if owner_epoch is not None:
+        receiver["owner_epoch"] = owner_epoch
+    return receiver
+
+
+def _broadcast_ambiguous_candidates(
+    receiver: dict[str, Any],
+    provider: str,
+    candidates: list[dict[str, Any]],
+    event_log: EventLog,
+    owner_identity: dict[str, Any],
+    team_id: str | None,
+) -> dict[str, Any]:
+    candidate_ids = sorted(str(candidate.get("pane_id")) for candidate in candidates)
+    bucket = _ambiguous_debounce_bucket()
+    incident_id = hashlib.sha256("\0".join([str(team_id or ""), *candidate_ids, bucket]).encode("utf-8")).hexdigest()[:16]
+    if any(event.get("event") == "leader_receiver.ambiguous_candidates" and event.get("incident_id") == incident_id for event in event_log.tail(200)):
+        return {"incident_id": incident_id, "deduped": True}
+    prompt = _ambiguous_candidate_prompt(team_id, len(candidates))
+    event_log.write(
+        "leader_receiver.ambiguous_candidates",
+        incident_id=incident_id,
+        old_pane_id=receiver.get("pane_id"),
+        candidates=candidate_ids,
+        provider=provider,
+        team_id=team_id,
+        uuid_prefix=_uuid_prefix(owner_identity),
+        debounce_bucket=bucket,
+    )
+    for candidate in candidates:
+        pane_id = str(candidate.get("pane_id") or "")
+        injected = _tmux_inject_text(
+            pane_id,
+            prompt,
+            "Enter",
+            f"team-agent-leader-ambiguous-{incident_id}-{pane_id.strip('%')}",
+            provider=provider,
+        )
+        event_log.write(
+            "leader_receiver.ambiguous_candidate_queued",
+            incident_id=incident_id,
+            pane_id=pane_id,
+            ok=bool(injected.get("ok")),
+            error=injected.get("error"),
+        )
+    return {"incident_id": incident_id, "deduped": False}
+
+
+def _ambiguous_debounce_bucket() -> str:
+    now = datetime.now(timezone.utc)
+    epoch = int(now.timestamp() // _AMBIGUOUS_DEBOUNCE_SECONDS) * _AMBIGUOUS_DEBOUNCE_SECONDS
+    return datetime.fromtimestamp(epoch, timezone.utc).isoformat()
+
+
+def _ambiguous_candidate_prompt(team_id: str | None, candidate_count: int) -> str:
+    others = max(candidate_count - 1, 0)
+    return (
+        f"Team `{team_id or 'current'}` has no bound leader. This window and {others} other window(s) all qualify. "
+        "To claim this window as the team leader, run: `team-agent claim-leader --confirm`. "
+        "Only the first such call wins; subsequent calls from other windows will be refused."
+    )
+
+
+def _rediscovered_receiver(
+    receiver: dict[str, Any],
+    provider: str,
+    target: dict[str, Any],
+    event_log: EventLog,
+    owner_identity: dict[str, Any] | None,
+    invalidation_reason: str | None = None,
+) -> dict[str, Any]:
+    leader_uuid = _target_leader_session_uuid(target) or (owner_identity or {}).get("leader_session_uuid") or receiver.get("leader_session_uuid")
+    updated = _receiver_from_target(target, provider, leader_uuid)
+    updated["discovery"] = "stale_rediscovery_owner_identity" if owner_identity else "stale_rediscovery_unique_candidate"
     event_log.write(
         "leader_receiver.rediscovered",
         provider=provider,
@@ -299,6 +446,14 @@ def _rediscovered_receiver(
         candidate_count=1,
         owner_identity=owner_identity,
     )
+    event_log.write(
+        "leader_receiver.rebind_applied",
+        old_pane_id=receiver.get("pane_id"),
+        new_pane_id=updated["pane_id"],
+        reason=invalidation_reason,
+        owner_identity=owner_identity,
+        uuid_prefix=_uuid_prefix(owner_identity),
+    )
     return {"status": "updated", "receiver": updated, "owner_identity": owner_identity}
 
 
@@ -306,6 +461,26 @@ def _validate_leader_receiver(receiver: dict[str, Any]) -> dict[str, Any]:
     pane_info = _runtime_tmux_pane_info(receiver.get("pane_id"))
     if not pane_info:
         return {"ok": False, "reason": "leader_pane_missing", "error": "tmux pane does not exist"}
+    provider = str(receiver.get("provider") or "codex")
+    if not _leader_command_looks_usable(pane_info.get("pane_current_command", ""), provider):
+        return {
+            "ok": False,
+            "reason": "leader_pane_wrong_command",
+            "error": f"pane command {pane_info.get('pane_current_command')!r} is not a leader host",
+            "pane": pane_info,
+        }
+    expected_uuid = receiver.get("leader_session_uuid")
+    if expected_uuid:
+        actual_uuid = _leader_uuid_for_bound_pane(receiver, pane_info)
+        if not actual_uuid:
+            return {"ok": False, "reason": "leader_uuid_missing", "error": "bound pane has no TEAM_AGENT_LEADER_SESSION_UUID", "pane": pane_info}
+        if actual_uuid != expected_uuid:
+            return {
+                "ok": False,
+                "reason": "leader_uuid_mismatch",
+                "error": "bound pane TEAM_AGENT_LEADER_SESSION_UUID does not match stored team owner",
+                "pane": pane_info,
+            }
     capture = run_cmd(["tmux", "capture-pane", "-p", "-S", "-40", "-t", pane_info["pane_id"]], timeout=5)
     if capture.returncode != 0:
         return {
@@ -314,14 +489,7 @@ def _validate_leader_receiver(receiver: dict[str, Any]) -> dict[str, Any]:
             "error": capture.stderr.strip() or "tmux capture-pane failed",
             "pane": pane_info,
         }
-    warning = None
-    provider = str(receiver.get("provider") or "codex")
-    if not _leader_command_looks_usable(pane_info.get("pane_current_command", ""), provider):
-        warning = (
-            f"pane command {pane_info.get('pane_current_command')!r} is not a typical {provider} host; "
-            "continuing because tmux capture works"
-        )
-    return {"ok": True, "pane": pane_info, "capture": capture.stdout, "warning": warning}
+    return {"ok": True, "pane": pane_info, "capture": capture.stdout, "warning": None}
 
 
 def _leader_command_looks_usable(command: str, provider: str) -> bool:
@@ -330,7 +498,9 @@ def _leader_command_looks_usable(command: str, provider: str) -> bool:
     command_name = Path(command).name
     if provider == "codex":
         return command_name in {"codex", "node", "nodejs"}
-    return bool(command_name)
+    if provider in {"claude", "claude_code"}:
+        return command_name in {"claude", "claude.exe"}
+    return command_name in {"codex", "node", "nodejs", "claude", "claude.exe"}
 
 
 def _choose_leader_submit_key(provider: str, capture_text: str) -> tuple[str, str]: