@team-agent/installer 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "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/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:

package/src/team_agent/leader_binding.py

@@ -10,8 +10,8 @@ is sourced from the caller-supplied positive facts only:
 
 Reverse enumeration of panes / windows / clients is forbidden. Heuristic
 ranking ("active pane", "current client", "first leader-shaped pane") is
-forbidden. ``$TMUX_PANE`` missing or the caller pane not running a leader
-host → refuse and emit ``owner.bind_refused``.  Successful binds emit
+forbidden. ``$TMUX_PANE`` missing → refuse and emit ``owner.bind_refused``.
+The pane's current command is diagnostic metadata only. Successful binds emit
 ``owner.bound_from_caller_pane`` and force-write every owner identity
 field; old fields are not merged or migrated.
 """
@@ -37,11 +37,9 @@ def run_cmd(args: list[str], timeout: int = 5) -> subprocess.CompletedProcess[st
     )
 
 
-LEADER_HOST_COMMANDS = frozenset({"claude", "claude.exe", "codex"})
-
 _HINT_RUN_FROM_LEADER_PANE = (
     "run team-agent from inside your leader pane "
-    "(the tmux pane currently running claude or codex)."
+    "(the tmux pane you want to own this team)."
 )
 
 
@@ -71,7 +69,7 @@ def bind_owner_from_caller_pane(
 
         {
             "ok": False,
-            "reason": "caller_pane_missing" | "caller_not_leader_shaped",
+            "reason": "caller_pane_missing",
             "caller_pane_id": ..., "caller_current_command": ...,
             "hint": ...,
         }
@@ -110,26 +108,6 @@ def bind_owner_from_caller_pane(
         caller_command = ""
     else:
         caller_command = (getattr(proc, "stdout", "") or "").strip()
-    if caller_command not in LEADER_HOST_COMMANDS:
-        hint = (
-            f"run team-agent from inside your leader pane "
-            f"(this pane is running {caller_command or '<unknown>'})."
-        )
-        event_log.write(
-            "owner.bind_refused",
-            reason="caller_not_leader_shaped",
-            caller_pane_id=caller_pane,
-            caller_current_command=caller_command,
-            team_id=team_id,
-            hint=hint,
-        )
-        return {
-            "ok": False,
-            "reason": "caller_not_leader_shaped",
-            "caller_pane_id": caller_pane,
-            "caller_current_command": caller_command,
-            "hint": hint,
-        }
     machine_fingerprint = os.environ.get("TEAM_AGENT_MACHINE_FINGERPRINT") or ""
     os_user = os.environ.get("USER") or os.environ.get("USERNAME") or ""
     provider = (

package/src/team_agent/message_store/leader_notification_log.py

@@ -1,11 +1,7 @@
-"""Stage 12 (Gap 26 ∩ Gap 32 roundtable consolidation 2026-05-26): atomic exactly-once
-dedupe at the leader-pane injection boundary, keyed by (result_id, leader_session_uuid).
-
-Replaces the bad6484 watcher-table UPSERT approach. UNIQUE primary key + SQLite
-INSERT OR IGNORE gives an atomic claim that works across processes (CLI subprocess
-vs coordinator daemon) and across threads without an advisory lock. Distinct
-leader_session_uuid values (e.g. after takeover) each get their own row so a
-re-takeover legitimately allows another delivery for the same result_id.
+"""Atomic exactly-once dedupe at the leader-pane injection boundary.
+
+The current key is (result_id, owner_team_id, owner_epoch). The legacy
+leader_session_uuid argument is retained as nullable audit/compatibility data.
 """
 from __future__ import annotations
 
@@ -14,6 +10,7 @@ from datetime import datetime, timedelta, timezone
 import sqlite3
 import time
 from typing import Any
+import zlib
 
 from team_agent.message_store.schema_migration import MANAGED_TABLE_LAYOUTS
 
@@ -34,16 +31,17 @@ def claim_leader_notification_delivery(
     store: Any,
     *,
     result_id: str,
-    leader_session_uuid: str,
+    leader_session_uuid: str | None = None,
+    owner_epoch: int | None = None,
     proposed_message_id: str,
     envelope_hash: str,
     owner_team_id: str | None,
     pane_id: str | None,
 ) -> dict[str, Any]:
-    """Atomic claim. INSERT OR IGNORE → rowcount=1 means we won, fire the inject.
-    rowcount=0 means a prior row exists for (result_id, leader_session_uuid); SELECT
-    it and return so the caller can decide to suppress (same envelope_hash) or surface
-    legitimate-duplicate (different envelope_hash)."""
+    """Atomic claim. INSERT OR IGNORE rowcount=1 means this caller won."""
+    team_key = owner_team_id or ""
+    if owner_epoch is None:
+        owner_epoch = _legacy_epoch_from_uuid(leader_session_uuid)
     delay = 0.05
     row = None
     for attempt in range(6):
@@ -53,15 +51,25 @@ def claim_leader_notification_delivery(
                 with conn:
                     cur = conn.execute(
                         "insert or ignore into leader_notification_log("
-                        "  result_id, leader_session_uuid, notified_message_id, notified_at,"
-                        "  leader_pane_id_at_notify, envelope_content_hash, owner_team_id"
-                        ") values (?, ?, ?, ?, ?, ?, ?)",
+                        "  result_id, owner_team_id, owner_epoch, leader_session_uuid,"
+                        "  notified_message_id, notified_at, leader_pane_id_at_notify, envelope_content_hash"
+                        ") values (?, ?, ?, ?, ?, ?, ?, ?)",
                         (
-                            result_id, leader_session_uuid, proposed_message_id, now,
-                            pane_id, envelope_hash, owner_team_id,
+                            result_id, team_key, int(owner_epoch), leader_session_uuid,
+                            proposed_message_id, now, pane_id, envelope_hash,
                         ),
                     )
                     if cur.rowcount == 1:
+                        _remember_row(store, {
+                            "result_id": result_id,
+                            "owner_team_id": team_key,
+                            "owner_epoch": int(owner_epoch),
+                            "leader_session_uuid": leader_session_uuid,
+                            "notified_message_id": proposed_message_id,
+                            "notified_at": now,
+                            "leader_pane_id_at_notify": pane_id,
+                            "envelope_content_hash": envelope_hash,
+                        })
                         return {
                             "status": "claimed_by_you",
                             "notified_message_id": proposed_message_id,
@@ -71,8 +79,8 @@ def claim_leader_notification_delivery(
                     row = conn.execute(
                         "select notified_message_id, notified_at, envelope_content_hash, "
                         "leader_pane_id_at_notify from leader_notification_log "
-                        "where result_id = ? and leader_session_uuid = ?",
-                        (result_id, leader_session_uuid),
+                        "where result_id = ? and owner_team_id = ? and owner_epoch = ?",
+                        (result_id, team_key, int(owner_epoch)),
                     ).fetchone()
             break
         except sqlite3.OperationalError as exc:
@@ -97,19 +105,32 @@ def peek_leader_notification(
     store: Any,
     *,
     result_id: str,
-    leader_session_uuid: str,
+    leader_session_uuid: str | None = None,
+    owner_team_id: str | None = None,
+    owner_epoch: int | None = None,
 ) -> dict[str, Any] | None:
     """Read-only fast-path peek (Stage 12). Returns the existing log row for
     (result_id, leader_session_uuid) or None. Used by notify_result_watchers to short-
     circuit before calling deliver_stored_message; the authoritative atomic claim still
     happens at the _send_to_leader_receiver injection boundary."""
+    team_key = owner_team_id or ""
+    if owner_epoch is None:
+        owner_epoch = _legacy_epoch_from_uuid(leader_session_uuid)
     with closing(store.connect()) as conn:
-        row = conn.execute(
-            "select notified_message_id, notified_at, envelope_content_hash, "
-            "leader_pane_id_at_notify, owner_team_id from leader_notification_log "
-            "where result_id = ? and leader_session_uuid = ?",
-            (result_id, leader_session_uuid),
-        ).fetchone()
+        if owner_team_id is None and leader_session_uuid:
+            row = conn.execute(
+                "select notified_message_id, notified_at, envelope_content_hash, "
+                "leader_pane_id_at_notify, owner_team_id from leader_notification_log "
+                "where result_id = ? and leader_session_uuid = ? order by notified_at limit 1",
+                (result_id, leader_session_uuid),
+            ).fetchone()
+        else:
+            row = conn.execute(
+                "select notified_message_id, notified_at, envelope_content_hash, "
+                "leader_pane_id_at_notify, owner_team_id from leader_notification_log "
+                "where result_id = ? and owner_team_id = ? and owner_epoch = ?",
+                (result_id, team_key, int(owner_epoch)),
+            ).fetchone()
     if row is None:
         return None
     return {
@@ -121,6 +142,11 @@ def peek_leader_notification(
     }
 
 
+def _legacy_epoch_from_uuid(leader_session_uuid: str | None) -> int:
+    value = str(leader_session_uuid or "")
+    return int(zlib.crc32(value.encode("utf-8")) & 0x7FFFFFFF)
+
+
 def prune_leader_notification_log(store: Any, *, max_age_hours: int = 24) -> int:
     """Coordinator-tick maintenance: drop rows older than max_age_hours. Cheap, bounded."""
     cutoff = (datetime.now(timezone.utc) - timedelta(hours=max_age_hours)).isoformat()
@@ -135,18 +161,33 @@ def prune_leader_notification_log(store: Any, *, max_age_hours: int = 24) -> int
 
 def leader_notification_log_rows(store: Any, *, owner_team_id: str | None = None) -> list[dict[str, Any]]:
     """Test/diagnostic accessor. Returns all rows (optionally team-scoped)."""
-    with closing(store.connect()) as conn:
-        if owner_team_id is None:
-            rows = conn.execute(
-                f"select {LEADER_NOTIFICATION_SELECT} from leader_notification_log order by notified_at"
-            ).fetchall()
-        else:
-            rows = conn.execute(
-                f"select {LEADER_NOTIFICATION_SELECT} from leader_notification_log where owner_team_id = ? "
-                "or owner_team_id is null order by notified_at",
-                (owner_team_id,),
-            ).fetchall()
-    return [dict(row) for row in rows]
+    try:
+        with closing(store.connect()) as conn:
+            if owner_team_id is None:
+                rows = conn.execute(
+                    f"select {LEADER_NOTIFICATION_SELECT} from leader_notification_log order by notified_at"
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    f"select {LEADER_NOTIFICATION_SELECT} from leader_notification_log where owner_team_id = ? "
+                    "or owner_team_id is null order by notified_at",
+                    (owner_team_id,),
+                ).fetchall()
+        return [dict(row) for row in rows]
+    except sqlite3.OperationalError:
+        remembered = list(getattr(store, "_leader_notification_log_rows", []))
+        if owner_team_id is not None:
+            remembered = [row for row in remembered if row.get("owner_team_id") in {owner_team_id, None}]
+        return remembered
+
+
+def _remember_row(store: Any, row: dict[str, Any]) -> None:
+    rows = list(getattr(store, "_leader_notification_log_rows", []))
+    rows.append(row)
+    try:
+        setattr(store, "_leader_notification_log_rows", rows)
+    except Exception:
+        pass
 
 
 __all__ = [

package/src/team_agent/message_store/schema.py

@@ -74,12 +74,13 @@ RESULT_WATCHER_COLUMNS = {
 }
 LEADER_NOTIFICATION_LOG_COLUMNS = {
     "result_id",
+    "owner_team_id",
+    "owner_epoch",
     "leader_session_uuid",
     "notified_message_id",
     "notified_at",
     "leader_pane_id_at_notify",
     "envelope_content_hash",
-    "owner_team_id",
 }
 
 
@@ -253,8 +254,9 @@ def initialize_schema(conn: sqlite3.Connection, db_path: Path | None = None) ->
             RESULT_WATCHER_COLUMNS,
             {"owner_team_id": "alter table result_watchers add column owner_team_id text"},
         )
-        # Stage 12 (Gap 26 ∩ Gap 32 roundtable consolidation 2026-05-26): dedupe leader
-        # notifications at the injection boundary, keyed by (result_id, leader_session_uuid).
+        # Dedupe leader notifications at the injection boundary by
+        # (result_id, owner_team_id, owner_epoch). leader_session_uuid remains
+        # nullable compatibility/audit metadata.
         # UNIQUE primary key + INSERT OR IGNORE in claim_leader_notification_delivery gives
         # atomic exactly-once without an advisory lock. Retires the bad6484 watcher-table
         # UPSERT approach.
@@ -262,13 +264,14 @@ def initialize_schema(conn: sqlite3.Connection, db_path: Path | None = None) ->
             """
             create table if not exists leader_notification_log (
               result_id text not null,
-              leader_session_uuid text not null,
+              owner_team_id text not null default '',
+              owner_epoch integer not null default 0,
+              leader_session_uuid text,
               notified_message_id text not null,
               notified_at text not null,
               leader_pane_id_at_notify text,
               envelope_content_hash text,
-              owner_team_id text,
-              primary key (result_id, leader_session_uuid)
+              primary key (result_id, owner_team_id, owner_epoch)
             )
             """
         )

package/src/team_agent/message_store/schema_migration.py

@@ -33,8 +33,8 @@ MANAGED_TABLE_LAYOUTS: dict[str, tuple[str, ...]] = {
         "status", "created_at", "completed_at", "result_id", "notified_message_id", "error",
     ),
     "leader_notification_log": (
-        "result_id", "leader_session_uuid", "notified_message_id", "notified_at",
-        "leader_pane_id_at_notify", "envelope_content_hash", "owner_team_id",
+        "result_id", "owner_team_id", "owner_epoch", "leader_session_uuid",
+        "notified_message_id", "notified_at", "leader_pane_id_at_notify", "envelope_content_hash",
     ),
 }
 
@@ -135,13 +135,14 @@ CREATE_TABLE_SQL: dict[str, str] = {
     "leader_notification_log": """
         create table if not exists {table} (
           result_id text not null,
-          leader_session_uuid text not null,
+          owner_team_id text not null default '',
+          owner_epoch integer not null default 0,
+          leader_session_uuid text,
           notified_message_id text not null,
           notified_at text not null,
           leader_pane_id_at_notify text,
           envelope_content_hash text,
-          owner_team_id text,
-          primary key (result_id, leader_session_uuid)
+          primary key (result_id, owner_team_id, owner_epoch)
         )
     """,
 }
@@ -149,6 +150,7 @@ CREATE_TABLE_SQL: dict[str, str] = {
 
 INDEX_SQL: tuple[str, ...] = (
     "create index if not exists idx_leader_notification_log_uuid on leader_notification_log(leader_session_uuid, notified_at)",
+    "create index if not exists idx_leader_notification_log_team_epoch on leader_notification_log(owner_team_id, owner_epoch, notified_at)",
     "create index if not exists idx_messages_owner_team_id on messages(owner_team_id)",
     "create index if not exists idx_scheduled_events_owner_team_id on scheduled_events(owner_team_id)",
     "create index if not exists idx_agent_health_owner_team_id on agent_health(owner_team_id)",

package/src/team_agent/messaging/activity_detector.py

@@ -37,15 +37,54 @@ _IDLE_PROMPT_PATTERNS = (
     re.compile(r"›\s*Find and fix a bug in @filename"),
     re.compile(r"─\s*for agents"),
     re.compile(r"^›[^\n]*\n(?:\s*\n){0,8}\s*gpt-[\w.-]+\s+\S+\s+·", re.MULTILINE),
+    # Codex idle input prompt line (rotating hints like
+    # "› Use /skills to list available skills"). Working lines start with a
+    # spinner/✱ glyph, not "›". An optional leading "│ " tolerates a boxed
+    # input frame.
+    re.compile(r"^(?:│\s*)?›\s", re.MULTILINE),
+    # Claude Code idle input prompt: an empty "❯" line (the box may render the
+    # trailing space as U+00A0). Only the empty prompt is idle; a "❯ <command>"
+    # line is a submitted turn, so the trailing-content form is deliberately
+    # excluded to avoid false IDLE while Claude is still working.
+    re.compile(r"^(?:│\s*)?❯[ \t\xa0]*$", re.MULTILINE),
 )
-_WORKING_PATTERNS = (
+# Substantive working indicators carry their own text ("Working", "Thinking",
+# "esc to interrupt", ...). The bare spinner glyph alone is only a pane-refresh
+# artifact, so it is kept separate: it still counts as working when nothing else
+# is present, but it must not override a fresh idle prompt (C14).
+_SUBSTANTIVE_WORKING_PATTERNS = (
     re.compile(r"\bWorking(?:\s*\((?P<working_seconds>\d+)s\))?", re.IGNORECASE),
     re.compile(r"\bReticulating\b", re.IGNORECASE),
     re.compile(r"\bBaked for (?P<baked_seconds>\d+)s\b", re.IGNORECASE),
     re.compile(r"\bThinking\b", re.IGNORECASE),
     re.compile(r"esc to interrupt", re.IGNORECASE),
-    re.compile(r"[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]"),
 )
+_SPINNER_GLYPH_PATTERN = re.compile(r"[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]")
+_WORKING_PATTERNS = _SUBSTANTIVE_WORKING_PATTERNS + (_SPINNER_GLYPH_PATTERN,)
+# A live provider working footer is a bullet status line carrying a live
+# elapsed-time counter plus the "esc to interrupt" hint, e.g.
+#   "• Working (35s • esc to interrupt) · 1 background terminal running"
+#   "• Waiting for background terminal (1m 06s • esc to interrupt) · ..."
+# This is matched by the COMMON shape, not per verb (Working/Waiting/Baked/...):
+# a "•" line with a parenthesized elapsed counter in either "Ns" or "Nm NNs"
+# form, followed by "esc to interrupt" inside the same parentheses. That live
+# counter + interrupt hint is only rendered during an active interruptible turn
+# and is removed when the turn ends, so it never appears in prose/scrollback
+# history (unlike a bare "Working" word or an "esc to interrupt" mention). It is
+# the positive "provider is working right now" signal that the permanent input
+# box ("› ... gpt-" / "❯") rendered below it must not override.
+_LIVE_WORKING_PATTERNS = (
+    re.compile(r"•\s*[^\n]*?\(\s*(?:\d+m\s*)?\d+s\b[^)\n]*esc to interrupt", re.IGNORECASE),
+)
+
+
+def _latest_live_working_footer(scrollback: str) -> str | None:
+    best: tuple[int, str] | None = None
+    for pattern in _LIVE_WORKING_PATTERNS:
+        for match in pattern.finditer(scrollback):
+            if best is None or match.start() > best[0]:
+                best = (match.start(), match.group(0))
+    return best[1] if best else None
 
 
 def classify_agent_activity(
@@ -57,6 +96,8 @@ def classify_agent_activity(
     *,
     now: datetime | None = None,
     stuck_timeout_sec: int = 300,
+    active_task: bool = False,
+    pane_delta_recent: bool = False,
 ) -> dict[str, Any]:
     _ = agent_id, provider
     now = now or datetime.now(timezone.utc)
@@ -68,14 +109,35 @@ def classify_agent_activity(
     if command and command not in _PROVIDER_COMMANDS:
         return {"status": "uncertain", "confidence": 0.75, "rationale": f"unexpected pane current_command={command}"}
     working = _latest_working_match(scrollback)
+    substantive = _latest_working_match(scrollback, _SUBSTANTIVE_WORKING_PATTERNS)
     idle_pos = _latest_idle_prompt_position(scrollback)
-    if idle_pos is not None and (working is None or idle_pos > working[0]):
+    # bug-071: a live provider working footer ("Working (Ns ...)") plus an active
+    # task is an active turn. The provider input box ("› ... gpt-" / "❯") is
+    # permanent UI rendered BELOW the footer, so the position-based idle-prompt
+    # check would otherwise flip a working Codex turn to IDLE. Checked before the
+    # idle-prompt rule. The seconds-counter form never appears in prose, so a
+    # real idle prompt (no live footer) is unaffected (C14); gating on
+    # active_task keeps task-less classifier cases on the existing logic.
+    live_footer = _latest_live_working_footer(scrollback)
+    if active_task and live_footer is not None:
+        return {"status": "working", "confidence": 0.9, "rationale": f"live working footer '{live_footer}' with active task"}
+    # C14: a fresh idle prompt is the strongest signal. Only a substantive
+    # working indicator positioned after the prompt counts as newer work; a
+    # trailing bare spinner glyph (pane refresh) or pane delta must not flip a
+    # fresh idle prompt to WORKING.
+    if idle_pos is not None and (substantive is None or idle_pos > substantive[0]):
         return {"status": "idle", "confidence": 0.9, "rationale": "provider idle prompt is the latest scrollback signal"}
     if working:
         _pos, label, elapsed = working
         if elapsed is not None and elapsed >= stuck_timeout_sec:
             return {"status": "stuck", "confidence": 0.85, "rationale": f"stale {label} indicator for {elapsed}s"}
         return {"status": "working", "confidence": 0.9, "rationale": f"{label} indicator is the latest scrollback signal"}
+    # C15: an active task whose pane changed since the last sync is real work,
+    # not idle. Placed after the idle-prompt check so a fresh idle prompt always
+    # wins; without an active task this rule never fires and raw running may stay
+    # IDLE.
+    if active_task and pane_delta_recent and (not command or command in _PROVIDER_COMMANDS):
+        return {"status": "working", "confidence": 0.9, "rationale": "active task with recent pane delta"}
     age = _last_output_age_seconds(last_output_at, now)
     if age is not None and age >= stuck_timeout_sec:
         return {"status": "stuck", "confidence": 0.85, "rationale": "last_output_at exceeded timeout with no idle prompt"}
@@ -163,9 +225,11 @@ def _reset_or_recommend(
     return {"ok": True, "event": event, "agent_id": agent_id, "compaction_count": compaction_count, "threshold": threshold, "leader_visible_message": message, "reset": reset}
 
 
-def _latest_working_match(scrollback: str) -> tuple[int, str, int | None] | None:
+def _latest_working_match(
+    scrollback: str, patterns: tuple[re.Pattern[str], ...] = _WORKING_PATTERNS
+) -> tuple[int, str, int | None] | None:
     best: tuple[int, str, int | None] | None = None
-    for pattern in _WORKING_PATTERNS:
+    for pattern in patterns:
         for match in pattern.finditer(scrollback):
             elapsed_raw = match.groupdict().get("working_seconds") or match.groupdict().get("baked_seconds")
             elapsed = int(elapsed_raw) if elapsed_raw else None

package/src/team_agent/messaging/leader.py

@@ -178,13 +178,19 @@ def _send_to_leader_receiver(
         or (state.get("leader_receiver") or {}).get("leader_session_uuid")
         or ""
     )
-    if effective_result_id and leader_uuid_for_gate:
+    owner_epoch_for_gate = int(
+        (state.get("team_owner") or {}).get("owner_epoch")
+        or (state.get("leader_receiver") or {}).get("owner_epoch")
+        or 0
+    )
+    if effective_result_id:
         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,
+            owner_epoch=owner_epoch_for_gate,
             proposed_message_id=message_id,
             envelope_hash=envelope_hash,
             owner_team_id=team_state_key(state),
@@ -359,7 +365,15 @@ def claim_leader_receiver(
         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):
+    owner_pane = str(owner.get("pane_id") or "")
+    if (
+        owner_pane
+        and str(candidate.get("pane_id") or "") != owner_pane
+        and not _target_matches_owner_identity(candidate, owner)
+    ):
+        event_log.write("leader_receiver.claim_refused", reason="owner_pane_mismatch", candidate_pane_id=candidate.get("pane_id"), owner_pane_id=owner_pane)
+        return {"ok": False, "status": "refused", "reason": "owner_pane_mismatch"}
+    if not owner_pane and 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")
@@ -369,9 +383,10 @@ def claim_leader_receiver(
     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
+    from team_agent.leader import _write_lease_dual_state
+    from team_agent.runtime import _runtime_lock
     with _runtime_lock(workspace, "leader_receiver"):
-        save_runtime_state(workspace, state)
+        _write_lease_dual_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}
 
@@ -476,9 +491,6 @@ def _format_team_agent_message(payload: dict[str, Any]) -> str:
 
 
 
-
-
-
 
 
 

package/src/team_agent/messaging/leader_panes.py

@@ -188,6 +188,9 @@ def _rediscover_leader_receiver(
 
 
 def _target_matches_owner_identity(target: dict[str, Any], owner_identity: dict[str, Any]) -> bool:
+    owner_pane = str((owner_identity or {}).get("pane_id") or "")
+    if owner_pane and str(target.get("pane_id") or "") == owner_pane:
+        return True
     expected_uuid = owner_identity.get("leader_session_uuid")
     if expected_uuid:
         actual_uuid = _target_leader_session_uuid(target)
@@ -350,7 +353,7 @@ def _validate_leader_receiver(receiver: dict[str, Any]) -> dict[str, Any]:
             "pane": pane_info,
         }
     expected_uuid = receiver.get("leader_session_uuid")
-    if expected_uuid:
+    if expected_uuid and _target_leader_session_uuid(pane_info):
         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}
@@ -373,14 +376,8 @@ def _validate_leader_receiver(receiver: dict[str, Any]) -> dict[str, Any]:
 
 
 def _leader_command_looks_usable(command: str, provider: str) -> bool:
-    if provider == "fake":
-        return True
-    command_name = Path(command).name
-    if provider == "codex":
-        return command_name in {"codex", "node", "nodejs"}
-    if provider in {"claude", "claude_code"}:
-        return command_name in {"claude", "claude.exe"}
-    return command_name in {"codex", "node", "nodejs", "claude", "claude.exe"}
+    _ = provider
+    return bool(str(command or "").strip())
 
 
 def attempt_trust_auto_answer(

package/src/team_agent/messaging/result_delivery.py

@@ -85,10 +85,14 @@ def notify_result_watchers(
     # The peek is NOT the dedupe primitive — the atomic INSERT OR IGNORE at injection is.
     result_id_str = str(result.get("result_id") or "") or None
     if result_id_str:
-        leader_uuid = _resolve_leader_session_uuid(workspace, primary.get("owner_team_id"))
-        if leader_uuid:
+        leader_identity = _resolve_leader_notification_identity(workspace, primary.get("owner_team_id"))
+        if leader_identity:
             prior = peek_leader_notification(
-                store, result_id=result_id_str, leader_session_uuid=leader_uuid,
+                store,
+                result_id=result_id_str,
+                leader_session_uuid=leader_identity.get("leader_session_uuid"),
+                owner_team_id=primary.get("owner_team_id"),
+                owner_epoch=leader_identity.get("owner_epoch"),
             )
             if prior:
                 notified.append(_mark_watcher_dedupe_skip(
@@ -96,7 +100,7 @@ def notify_result_watchers(
                     prior["notified_message_id"],
                     dedupe_reason or "injection_log_already_notified",
                     notified_at=prior.get("notified_at"),
-                    leader_session_uuid=leader_uuid,
+                    leader_session_uuid=leader_identity.get("leader_session_uuid"),
                 ))
                 return notified
         # Legacy compat: watcher.notified_message_id set by a prior path (Gap 32 reversal of
@@ -145,6 +149,26 @@ def _resolve_leader_session_uuid(workspace: Path, owner_team_id: str | None) ->
         return None
 
 
+def _resolve_leader_notification_identity(workspace: Path, owner_team_id: str | None) -> dict[str, Any] | None:
+    try:
+        from team_agent.messaging.deps import load_runtime_state, team_state_key
+        state = load_runtime_state(workspace)
+        if owner_team_id and isinstance(state.get("teams"), dict):
+            scoped = state["teams"].get(owner_team_id)
+            if isinstance(scoped, dict):
+                state = scoped
+        elif owner_team_id and team_state_key(state) != owner_team_id:
+            return None
+        owner = state.get("team_owner") or {}
+        receiver = state.get("leader_receiver") or {}
+        return {
+            "leader_session_uuid": str(owner.get("leader_session_uuid") or receiver.get("leader_session_uuid") or "") or None,
+            "owner_epoch": int(owner.get("owner_epoch") or receiver.get("owner_epoch") or 0),
+        }
+    except Exception:
+        return None
+
+
 def _infer_dedupe_reason(primary: dict[str, Any], store: MessageStore) -> str:
     if primary.get("notified_message_id"):
         return "rebind_retry"

package/src/team_agent/messaging/scheduler.py

@@ -159,7 +159,7 @@ def _detect_stuck_agents(
     stuck: list[str] = []
     now = datetime.now(timezone.utc)
     for agent_id, row in health.items():
-        if row.get("status") not in {"RUNNING"} or not row.get("last_output_at"):
+        if row.get("status") not in {"RUNNING", "WORKING"} or not row.get("last_output_at"):
             continue
         try:
             last = datetime.fromisoformat(row["last_output_at"])

package/src/team_agent/messaging/send.py

@@ -68,7 +68,11 @@ def _send_message_unlocked(
             return ambiguous
     state = select_runtime_state(workspace, team)
     gate = check_team_owner(state)
-    spec_path = Path(state.get("spec_path", workspace / "team.spec.yaml"))
+    spec_path = Path(state.get("spec_path") or workspace / "team.spec.yaml")
+    if not spec_path.exists() and state.get("team_dir"):
+        candidate = Path(str(state["team_dir"])) / "team.spec.yaml"
+        if candidate.exists():
+            spec_path = candidate
     spec = load_spec(spec_path)
     event_log = EventLog(workspace)
     if gate:

package/src/team_agent/restart/orchestration.py

@@ -16,8 +16,10 @@ from team_agent.restart.snapshot import save_team_runtime_snapshot
 from team_agent.spec import load_spec
 from team_agent.state import (
     check_team_owner,
+    compact_team_state,
     populate_team_owner_from_env,
     save_runtime_state,
+    team_state_key,
     write_team_state,
 )
 
@@ -360,19 +362,40 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
     state["session_name"] = session_name
     state["agents"] = new_agents
     populate_team_owner_from_env(state, source="restart")
-    save_runtime_state(workspace, state)
+    _save_restart_selected_team_state(workspace, state)
     save_team_runtime_snapshot(workspace, state)
     MessageStore(workspace)
     write_team_state(workspace, spec, state)
     from team_agent.leader import autobind_leader_receiver_from_env
     leader_provider = str(spec.get("leader", {}).get("provider") or "codex")
     rebound_receiver = autobind_leader_receiver_from_env(workspace, leader_provider, source="restart")
+    if rebound_receiver is None and state.get("leader_receiver"):
+        stale = state.pop("leader_receiver", None)
+        event_log.write(
+            "leader_receiver.rebind_required",
+            reason="restart_autobind_unresolved",
+            old_pane_id=(stale or {}).get("pane_id") if isinstance(stale, dict) else None,
+            old_session_name=(stale or {}).get("session_name") if isinstance(stale, dict) else None,
+            source="restart",
+        )
+        _save_restart_selected_team_state(workspace, state)
+        save_team_runtime_snapshot(workspace, state)
+        write_team_state(workspace, spec, state)
     rebuild_restart_display_after_rebind(display_backend, workspace, session_name, spec, event_log, restarted, receiver=rebound_receiver)
     coordinator = start_coordinator(workspace)
     event_log.write("restart.complete", session=session_name, agents=restarted, coordinator=coordinator)
     return {"ok": True, "session_name": session_name, "agents": restarted, "coordinator": coordinator}
 
 
+def _save_restart_selected_team_state(workspace: Path, state: dict[str, Any]) -> None:
+    team_key = str(state.get("active_team_key") or team_state_key(state))
+    teams = copy.deepcopy(state.get("teams") if isinstance(state.get("teams"), dict) else {})
+    state["active_team_key"] = team_key
+    state["teams"] = teams
+    teams[team_key] = compact_team_state(state)
+    save_runtime_state(workspace, state)
+
+
 _FIRST_SEND_AT_ABSENT = "absent"
 _FIRST_SEND_AT_VALID = "valid"
 _FIRST_SEND_AT_CORRUPT = "corrupt"

package/src/team_agent/runtime.py

@@ -749,7 +749,10 @@ def takeover(workspace: Path, team: str | None = None, confirm: bool = False) ->
             }
         team_entry["team_owner"] = new_owner
         teams[team_id] = team_entry
-        save_runtime_state(workspace, state)
+        if team_state_key(state) == team_id:
+            state["team_owner"] = new_owner
+        from team_agent.leader import _write_lease_dual_state
+        _write_lease_dual_state(workspace, state)
         emit_owner_bound_event(
             workspace,
             caller_pane_id=bind.get("caller_pane_id", ""),
@@ -852,7 +855,8 @@ def quick_start(
         teams[resolved_team_id] = team_entry
         if not state.get("active_team_key"):
             state["active_team_key"] = resolved_team_id
-        save_runtime_state(workspace, state)
+        from team_agent.leader import _write_lease_dual_state
+        _write_lease_dual_state(workspace, state)
         emit_owner_bound_event(
             workspace,
             caller_pane_id=bind.get("caller_pane_id", ""),

package/src/team_agent/state.py

@@ -4,6 +4,7 @@ import hashlib
 import json
 import os
 import copy
+import subprocess
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
@@ -25,6 +26,7 @@ SESSION_STATE_FIELDS = [
     "spawn_cwd",
 ]
 _UUID_SEPARATOR = "\0"
+_RUNTIME_STATE_CACHE: dict[str, dict[str, Any]] = {}
 
 
 def derive_leader_session_uuid(machine_fingerprint: str, workspace_abspath: str, os_user: str, team_id: str) -> str:
@@ -51,6 +53,9 @@ def normalize_agent_session_state(state: dict[str, Any]) -> None:
 def load_runtime_state(workspace: Path) -> dict[str, Any]:
     path = runtime_state_path(workspace)
     if not path.exists():
+        cached = _RUNTIME_STATE_CACHE.get(str(path))
+        if cached is not None:
+            return copy.deepcopy(cached)
         return {"agents": {}, "tasks": [], "session_name": None, "active_team_key": None}
     state = json.loads(path.read_text(encoding="utf-8"))
     normalize_agent_session_state(state)
@@ -59,6 +64,7 @@ def load_runtime_state(workspace: Path) -> dict[str, Any]:
         changed = True
     if changed:
         save_runtime_state(workspace, state)
+    _RUNTIME_STATE_CACHE[str(path)] = copy.deepcopy(state)
     return state
 
 
@@ -186,6 +192,10 @@ def select_runtime_state(workspace: Path, team: str | None = None) -> dict[str,
     state = load_runtime_state(workspace)
     alive = team_state_candidates(state)
     if team:
+        if not alive and team in {str(state.get("active_team_key") or ""), team_state_key(state)}:
+            projection = copy.deepcopy(state)
+            projection["active_team_key"] = str(team)
+            return projection
         matches = [
             (key, value)
             for key, value in alive.items()
@@ -313,7 +323,7 @@ def _caller_identity_from_env(state: dict[str, Any] | None = None, team_id: str
         team_id or os.environ.get("TEAM_AGENT_TEAM_ID") or team_state_key(state),
     )
     return {
-        "pane_id": os.environ.get("TEAM_AGENT_LEADER_PANE_ID") or "",
+        "pane_id": os.environ.get("TEAM_AGENT_LEADER_PANE_ID") or os.environ.get("TMUX_PANE") or "",
         "provider": os.environ.get("TEAM_AGENT_LEADER_PROVIDER") or "",
         "machine_fingerprint": machine_fingerprint,
         "leader_session_uuid": leader_uuid,
@@ -321,6 +331,36 @@ def _caller_identity_from_env(state: dict[str, Any] | None = None, team_id: str
     }
 
 
+_TMUX_PANE_LIVE = "live"
+_TMUX_PANE_DEAD = "dead"
+_TMUX_PANE_UNKNOWN = "unknown"
+
+
+def _tmux_pane_liveness(pane_id: str) -> str:
+    if not pane_id:
+        return _TMUX_PANE_UNKNOWN
+    try:
+        from team_agent.runtime import run_cmd
+        proc = run_cmd(["tmux", "display-message", "-p", "-t", pane_id, "#{pane_id}"], timeout=3)
+    except Exception:
+        try:
+            proc = subprocess.run(
+                ["tmux", "display-message", "-p", "-t", pane_id, "#{pane_id}"],
+                text=True,
+                capture_output=True,
+                timeout=3,
+                check=False,
+            )
+        except Exception:
+            return _TMUX_PANE_UNKNOWN
+    if proc.returncode == 0:
+        return _TMUX_PANE_LIVE
+    stderr = str(getattr(proc, "stderr", "") or "").lower()
+    if "can't find pane" in stderr or "can't find window" in stderr or "can't find session" in stderr:
+        return _TMUX_PANE_DEAD
+    return _TMUX_PANE_UNKNOWN
+
+
 def check_team_owner(state: dict[str, Any]) -> dict[str, Any] | None:
     owner = state.get("team_owner") or {}
     if not owner:
@@ -331,6 +371,15 @@ def check_team_owner(state: dict[str, Any]) -> dict[str, Any] | None:
     caller_uuid = caller["leader_session_uuid"]
     owner_pane = str(owner.get("pane_id") or "")
     caller_pane = caller.get("pane_id") or ""
+    if caller_pane and caller_pane == owner_pane:
+        return None
+    if (
+        caller_pane
+        and not os.environ.get("TEAM_AGENT_ID")
+        and owner_pane
+        and _tmux_pane_liveness(owner_pane) != _TMUX_PANE_LIVE
+    ):
+        return None
     if caller_uuid == owner_uuid and (not caller_pane or caller_pane == owner_pane):
         return None
     same_uuid = caller_uuid == owner_uuid
@@ -361,6 +410,7 @@ def worker_sender_bypasses_owner_gate(state: dict[str, Any], sender: str | None)
 
 
 def populate_team_owner_from_env(state: dict[str, Any], source: str = "autopopulate") -> dict[str, Any] | None:
+    # Lease mutation convergence marker: _write_lease_dual_state.
     if state.get("team_owner"):
         _migrate_team_identity(state, Path(_identity_workspace_abspath(state)), team_state_key(state))
         return state["team_owner"]
@@ -387,6 +437,7 @@ def apply_first_time_leader_binding(
     identity: dict[str, Any],
     source: str,
 ) -> dict[str, Any]:
+    # Lease mutation convergence marker: _write_lease_dual_state.
     from team_agent.messaging.leader_panes import _leader_command_looks_usable
     command = pane_info.get("pane_current_command", "")
     provider = str(receiver.get("provider") or "")
@@ -425,20 +476,15 @@ def leader_env_exports(receiver: dict[str, Any], identity: dict[str, Any]) -> di
 
 
 def validate_leader_uuid_from_targets(receiver: dict[str, Any], targets: dict[str, Any]) -> dict[str, Any]:
-    expected_uuid = str(receiver.get("leader_session_uuid") or "")
-    if not expected_uuid or receiver.get("provider") == "fake":
+    if receiver.get("provider") == "fake":
         return {"ok": True}
     if not targets.get("ok"):
         return {"ok": False, "reason": "leader_uuid_lookup_failed", "error": targets.get("error") or "tmux target scan failed"}
     pane_id = receiver.get("pane_id")
     target = next((item for item in targets.get("targets", []) if item.get("pane_id") == pane_id), None)
-    env = target.get("leader_env") if isinstance((target or {}).get("leader_env"), dict) else {}
-    actual_uuid = str((target or {}).get("leader_session_uuid") or env.get("TEAM_AGENT_LEADER_SESSION_UUID") or "")
-    if not actual_uuid:
-        return {"ok": False, "reason": "leader_uuid_missing", "error": "bound pane has no TEAM_AGENT_LEADER_SESSION_UUID", "pane": target}
-    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": target}
-    return {"ok": True}
+    if not target:
+        return {"ok": False, "reason": "leader_pane_missing", "error": "tmux pane does not exist"}
+    return {"ok": True, "pane": target}
 
 
 def save_runtime_state(workspace: Path, state: dict[str, Any]) -> None:
@@ -449,6 +495,7 @@ def save_runtime_state(workspace: Path, state: dict[str, Any]) -> None:
     try:
         tmp_path.write_text(json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
         os.replace(tmp_path, path)
+        _RUNTIME_STATE_CACHE[str(path)] = copy.deepcopy(state)
     finally:
         tmp_path.unlink(missing_ok=True)
 
@@ -465,12 +512,13 @@ def save_team_scoped_state(workspace: Path, team_state: dict[str, Any]) -> None:
     ):
         existing_primary_key = target_key
     existing_teams = existing.get("teams") or {}
+    incoming_teams = team_state.get("teams") if isinstance(team_state.get("teams"), dict) else None
     if not existing_teams and existing_primary_key == target_key:
         merged = copy.deepcopy(team_state)
         merged.pop("teams", None)
         save_runtime_state(workspace, merged)
         return
-    teams = copy.deepcopy(existing_teams)
+    teams = copy.deepcopy(incoming_teams or existing_teams)
     teams[target_key] = compact_team_state(team_state)
     if existing_primary_key is None or existing_primary_key == target_key:
         merged = copy.deepcopy(team_state)