@team-agent/installer 0.2.1 → 0.2.2

package/src/team_agent/messaging/result_delivery.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 import json
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
 from team_agent.events import EventLog
 from team_agent.message_store import MessageStore
+from team_agent.message_store.leader_notification_log import peek_leader_notification
+from team_agent.message_store.result_watchers import leader_notified_message_id_for_result
 from team_agent.messaging.deps import send_message
 from team_agent.messaging.internal_delivery import deliver_stored_message
 
@@ -22,7 +25,13 @@ def retry_result_deliveries(workspace: Path, event_log: EventLog) -> list[dict[s
         row = store.result_by_id(str(watcher["result_id"]))
         if not row:
             continue
-        notified.extend(notify_result_watchers(workspace, _result_entry_from_row(row), event_log, watchers=[watcher]))
+        notified.extend(notify_result_watchers(
+            workspace,
+            _result_entry_from_row(row),
+            event_log,
+            watchers=[watcher],
+            dedupe_reason="rebind_retry",
+        ))
     return notified
 
 
@@ -31,6 +40,7 @@ def notify_result_watchers(
     result: dict[str, Any],
     event_log: EventLog,
     watchers: list[dict[str, Any]] | None = None,
+    dedupe_reason: str | None = None,
 ) -> list[dict[str, Any]]:
     store = MessageStore(workspace)
     candidates = [
@@ -67,9 +77,44 @@ def notify_result_watchers(
             }
         )
     attempts = result_delivery_attempts(event_log, primary["watcher_id"], str(result.get("result_id") or ""))
+    # Stage 12 (Gap 26 ∩ Gap 32 roundtable consolidation 2026-05-26): exactly-once dedupe
+    # lives in leader_notification_log keyed by (result_id, leader_session_uuid) and is
+    # consulted atomically at the injection boundary inside _send_to_leader_receiver. Here
+    # we add a read-only fast-path peek so concurrent notify_result_watchers calls for the
+    # same result short-circuit without spinning up a deliver_stored_message round-trip.
+    # 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:
+            prior = peek_leader_notification(
+                store, result_id=result_id_str, leader_session_uuid=leader_uuid,
+            )
+            if prior:
+                notified.append(_mark_watcher_dedupe_skip(
+                    store, event_log, primary, result, attempts,
+                    prior["notified_message_id"],
+                    dedupe_reason or "injection_log_already_notified",
+                    notified_at=prior.get("notified_at"),
+                    leader_session_uuid=leader_uuid,
+                ))
+                return notified
+        # Legacy compat: watcher.notified_message_id set by a prior path (Gap 32 reversal of
+        # 78055bc, or any pre-Stage-12 code) also blocks redelivery. This preserves the
+        # Stage 11.9-11.12 era contract while the new gate (leader_notification_log) is the
+        # authoritative dedupe primitive going forward.
+        legacy_canonical = leader_notified_message_id_for_result(
+            store, primary.get("owner_team_id"), result_id_str,
+        )
+        if legacy_canonical:
+            notified.append(_mark_watcher_dedupe_skip(
+                store, event_log, primary, result, attempts,
+                legacy_canonical,
+                dedupe_reason or "rebind_retry",
+            ))
+            return notified
     existing = delivered_result_message(
-        store,
-        str(result.get("result_id") or ""),
+        store, str(result.get("result_id") or ""),
         task_id=result.get("task_id"),
         owner_team_id=primary.get("owner_team_id"),
     )
@@ -83,6 +128,75 @@ def notify_result_watchers(
     return notified
 
 
+def _resolve_leader_session_uuid(workspace: Path, owner_team_id: str | None) -> str | None:
+    """Helper: read the team's leader_session_uuid from runtime state for gate lookups."""
+    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 {}
+        return str(owner.get("leader_session_uuid") or "") or None
+    except Exception:
+        return None
+
+
+def _infer_dedupe_reason(primary: dict[str, Any], store: MessageStore) -> str:
+    if primary.get("notified_message_id"):
+        return "rebind_retry"
+    return "watcher_duplicate"
+
+
+def _mark_watcher_dedupe_skip(
+    store: MessageStore,
+    event_log: EventLog,
+    watcher: dict[str, Any],
+    result: dict[str, Any],
+    attempts: int,
+    canonical_message_id: str,
+    reason: str,
+    *,
+    notified_at: str | None = None,
+    leader_session_uuid: str | None = None,
+) -> dict[str, Any]:
+    original_message_id = watcher.get("notified_message_id")
+    # Stage 12: the canonical message_id (or sentinel from the gate) is auditing metadata
+    # here. The authoritative dedupe gate is leader_notification_log; this mark just keeps
+    # the watcher row from being re-picked by retry scans.
+    store.mark_result_watcher(
+        watcher["watcher_id"],
+        "notified",
+        result_id=result.get("result_id"),
+        notified_message_id=canonical_message_id,
+    )
+    event_log.write(
+        "leader_receiver.notification_dedupe_skip",
+        result_id=result.get("result_id"),
+        original_message_id=original_message_id,
+        suppressed_message_id=canonical_message_id,
+        reason=reason,
+        team_id=watcher.get("owner_team_id"),
+        watcher_id=watcher["watcher_id"],
+        task_id=result.get("task_id"),
+        agent_id=result.get("agent_id"),
+        attempt=attempts + 1,
+        leader_session_uuid=leader_session_uuid,
+        prior_notified_at=notified_at,
+    )
+    return {
+        "watcher_id": watcher["watcher_id"],
+        "result_id": result.get("result_id"),
+        "ok": True,
+        "message_id": canonical_message_id,
+        "deduped": True,
+        "dedupe_reason": reason,
+    }
+
+
 def _dedupe_watchers_for_result(
     watchers: list[dict[str, Any]],
 ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
@@ -114,11 +228,19 @@ def _deliver_result_to_watcher(
         return _mark_delivery_failed(store, event_log, watcher, result, attempts, str(exc))
     status = "notified" if delivery.get("ok") else "notify_failed"
     error = delivery.get("reason") or delivery.get("error")
+    # Stage 12: notified_message_id is now auditing metadata. The exactly-once contract
+    # lives in the leader_notification_log table consulted by _send_to_leader_receiver;
+    # whatever the gate suppresses comes back as ok=true deduped=true, and the watcher row
+    # records this as a successful notification with the canonical message_id.
+    persisted_message_id = (
+        delivery.get("canonical_message_id") if delivery.get("deduped")
+        else (delivery.get("message_id") if delivery.get("ok") else None)
+    )
     store.mark_result_watcher(
         watcher["watcher_id"],
         status,
         result_id=result.get("result_id"),
-        notified_message_id=delivery.get("message_id"),
+        notified_message_id=persisted_message_id,
         error=error,
     )
     event_log.write(
@@ -279,6 +401,99 @@ def watcher_matches_result(watcher: dict[str, Any], result: dict[str, Any]) -> b
     return (not task_id or task_id == result.get("task_id")) and (not agent_id or agent_id == result.get("agent_id"))
 
 
+def requeue_after_claim_leader(
+    workspace: Path,
+    store: MessageStore,
+    event_log: EventLog,
+    owner_team_id: str,
+    claimed_pane_id: str,
+    *,
+    incident_ts: str | None = None,
+) -> list[dict[str, Any]]:
+    """Post-claim hook (Gap 26 / Mac mini Stage 11 Scenarios 3, 11.10): re-route every
+    not-yet-delivered leader-bound notification to the newly claimed pane. Returns the
+    list of requeued watcher records (may be empty).
+
+    Stage 11.10 semantic reframe: claim-leader means "all not-yet-delivered leader-bound
+    notifications for this team_id reroute to the claimed pane". Watcher status is
+    irrelevant — `notified_message_id` is the only dedupe gate. Gap 32 exactly-once
+    contract still holds: notified_message_id non-null blocks redelivery.
+
+    Selection rules:
+      - watcher is scoped to this team (owner_team_id match)
+      - watcher has no notified_message_id (Gap 32 once-only)
+      - watcher's latest activity timestamp (completed_at fallback created_at) is
+        at-or-after incident_ts when provided; without an incident_ts every
+        un-notified watcher is requeued.
+      - watcher status is otherwise ignored (pending / delivery_blocked /
+        delivery_exhausted / notify_failed all become candidates).
+
+    Atomicity vs coordinator's own scheduled retry: just before flipping a watcher's
+    status, re-fetch the row from the store. If notified_message_id became non-null
+    in the gap (the scheduled retry beat us), emit a benign
+    leader_receiver.claim_requeue_already_in_flight event and skip. If the race
+    leaks past this check, Gap 32 dedupe inside notify_result_watchers still
+    guarantees exactly-once injection.
+    """
+    # Stage 11.12: CAS re-fetch + claim_requeue_already_in_flight event retired. The atomic
+    # UPSERT in notify_result_watchers (claim_leader_notification) is now the single race
+    # gate. We mark eligible watchers to notify_failed and let retry_result_deliveries route
+    # through the UPSERT — concurrent claim/scheduled-retry paths both pass through the
+    # same atomic claim and only one fires deliver_attempt.
+    incident_dt = _parse_iso(incident_ts)
+    requeued: list[dict[str, Any]] = []
+    for watcher in store.result_watchers(owner_team_id=owner_team_id):
+        if watcher.get("notified_message_id"):
+            continue
+        latest_ts = _parse_iso(watcher.get("completed_at")) or _parse_iso(watcher.get("created_at"))
+        if incident_dt and latest_ts and latest_ts < incident_dt:
+            continue
+        watcher_id = watcher["watcher_id"]
+        prior_state = str(watcher.get("status") or "")
+        store.mark_result_watcher(
+            watcher_id, "notify_failed",
+            result_id=watcher.get("result_id"),
+        )
+        event_log.write(
+            "leader_receiver.claim_requeue",
+            result_id=watcher.get("result_id"),
+            watcher_id=watcher_id,
+            prior_state=prior_state,
+            requeued_at=datetime.now(timezone.utc).isoformat(),
+            claimed_pane_id=claimed_pane_id,
+            team_id=owner_team_id,
+        )
+        requeued.append({
+            "watcher_id": watcher_id,
+            "result_id": watcher.get("result_id"),
+            "prior_state": prior_state,
+        })
+    if requeued:
+        try:
+            retry_result_deliveries(workspace, event_log)
+        except Exception as exc:
+            event_log.write(
+                "leader_receiver.claim_requeue_delivery_failed",
+                error=str(exc),
+                watcher_ids=[r["watcher_id"] for r in requeued],
+                team_id=owner_team_id,
+                claimed_pane_id=claimed_pane_id,
+            )
+    return requeued
+
+
+def _parse_iso(text: Any) -> datetime | None:
+    if not isinstance(text, str) or not text:
+        return None
+    try:
+        dt = datetime.fromisoformat(text.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
 def format_result_watcher_notification(result: dict[str, Any]) -> str:
     task_id = result.get("task_id") or "unknown task"
     agent_id = result.get("agent_id") or "unknown agent"

package/src/team_agent/messaging/results.py

@@ -359,36 +359,27 @@ def _refresh_leader_receiver_or_flag_rebind(
     receiver = state.get("leader_receiver") or {}
     if receiver.get("mode") != "direct_tmux":
         return state
-    validation = _validate_leader_receiver(receiver)
+    owner_identity = state.get("team_owner") or None
+    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 validation.get("ok"):
         return state
-    owner_identity = state.get("team_owner") or None
-    rediscovered = _rediscover_leader_receiver(receiver, event_log, owner_identity)
+    rediscovered = _rediscover_leader_receiver(
+        receiver_for_validation,
+        event_log,
+        owner_identity,
+        invalidation_reason=validation.get("reason"),
+        team_id=team_state_key(state),
+    )
     if rediscovered.get("status") == "updated":
         state["leader_receiver"] = rediscovered["receiver"]
         if persist:
             save_runtime_state(workspace, state)
         else:
             save_team_scoped_state(workspace, state)
-        event_log.write(
-            "leader_receiver.rebind_applied",
-            old_pane_id=receiver.get("pane_id"),
-            new_pane_id=rediscovered["receiver"].get("pane_id"),
-            reason=validation.get("reason"),
-            source="report_result_notify",
-            owner_identity=owner_identity,
-        )
         return state
-    event_log.write(
-        "leader_receiver.rebind_required",
-        old_pane_id=receiver.get("pane_id"),
-        reason=validation.get("reason"),
-        validation_error=validation.get("error"),
-        rediscovery_status=rediscovered.get("status"),
-        provider=receiver.get("provider"),
-        source="report_result_notify",
-        owner_identity=owner_identity,
-    )
     return state
 
 

package/src/team_agent/messaging/scheduler.py

@@ -409,8 +409,18 @@ def _recent_restart_or_reset_event(event_log: EventLog, agent_id: str, since: da
     for event in reversed(event_log.tail(200)):
         if event.get("event") not in _RESTART_RESET_EVENTS:
             continue
-        if event.get("agent_id") != agent_id and agent_id not in set(event.get("agents") or []):
-            continue
+        if event.get("agent_id") != agent_id:
+            agents_field = event.get("agents") or []
+            agent_ids: set[str] = set()
+            for entry in agents_field:
+                if isinstance(entry, str):
+                    agent_ids.add(entry)
+                elif isinstance(entry, dict):
+                    aid = entry.get("agent_id")
+                    if isinstance(aid, str):
+                        agent_ids.add(aid)
+            if agent_id not in agent_ids:
+                continue
         try:
             ts = datetime.fromisoformat(str(event.get("ts")))
         except ValueError:

package/src/team_agent/runtime.py

@@ -67,6 +67,8 @@ from team_agent.display import (
 from team_agent.leader import (
     attach_leader,
     attach_leader_to_state as _attach_leader_to_state,
+    claim_leader,
+    leader_identity,
     leader_session_name as _leader_session_name,
     leader_start_plan,
     start_leader,
@@ -438,12 +440,10 @@ for _name in (
     assert hasattr(_launch_pkg, _name), f"team_agent.launch missing {_name}"
 del _launch_pkg, _name
 
-# Leader lane re-exports keep runtime.attach_leader, runtime.start_leader,
-# runtime.leader_start_plan, runtime._attach_leader_to_state,
-# runtime._leader_session_name resolving for CLI handlers and tests.
+# Leader lane re-exports keep runtime leader helpers resolving for CLI handlers and tests.
 import team_agent.leader as _leader_pkg
 assert attach_leader is _leader_pkg.attach_leader
-for _name in ("attach_leader", "attach_leader_to_state", "leader_session_name", "leader_start_plan", "start_leader"):
+for _name in ("attach_leader", "attach_leader_to_state", "claim_leader", "leader_identity", "leader_session_name", "leader_start_plan", "start_leader"):
     assert hasattr(_leader_pkg, _name), f"team_agent.leader missing {_name}"
 del _leader_pkg, _name
 from team_agent.task_graph import ready_tasks, update_task_status

package/src/team_agent/rust_core.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import platform
 import re
 import shutil
 import subprocess
@@ -10,6 +11,18 @@ from typing import Any
 from team_agent.paths import repo_root
 
 
+_LEADER_ENV_KEYS = (
+    "TEAM_AGENT_LEADER_SESSION_UUID",
+    "TEAM_AGENT_LEADER_PANE_ID",
+    "TEAM_AGENT_LEADER_PROVIDER",
+    "TEAM_AGENT_MACHINE_FINGERPRINT",
+    "TEAM_AGENT_LEADER_SESSION_UUID_OVERRIDE",
+)
+_LEADER_SHAPED_COMMANDS = {"codex", "claude", "claude.exe", "node", "nodejs"}
+_PANE_ENV_SCAN_TIMEOUT_SECONDS = 2.0
+_run_subprocess = subprocess.run  # test-injectable indirection
+
+
 def core_binary() -> Path | None:
     configured = shutil.which("team-agent-core")
     if configured:
@@ -105,13 +118,13 @@ def list_targets() -> dict[str, Any]:
     result = call_core("list-targets")
     if result.get("ok"):
         return result
-    proc = subprocess.run(
+    proc = _run_subprocess(
         [
             "tmux",
             "list-panes",
             "-a",
             "-F",
-            "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}",
+            "#{pane_id}\t#{session_name}\t#{window_index}\t#{window_name}\t#{pane_index}\t#{pane_tty}\t#{pane_current_command}\t#{pane_active}\t#{pane_pid}",
         ],
         text=True,
         capture_output=True,
@@ -123,7 +136,7 @@ def list_targets() -> dict[str, Any]:
     targets = []
     for line in proc.stdout.splitlines():
         parts = line.split("\t")
-        if len(parts) != 8:
+        if len(parts) not in {8, 9}:
             continue
         target = {
             "pane_id": parts[0],
@@ -135,11 +148,152 @@ def list_targets() -> dict[str, Any]:
             "pane_current_command": parts[6],
             "pane_active": parts[7] == "1",
         }
+        pane_pid = parts[8].strip() if len(parts) == 9 else ""
+        if pane_pid:
+            target["pane_pid"] = pane_pid
         target["fingerprint"] = f"{target['session_name']}|{target['window_index']}|{target['pane_index']}|{target['pane_tty']}"
+        _attach_leader_env(target)
         targets.append(target)
     return {"ok": True, "targets": targets, "engine": "python_fallback", "fallback_reason": result.get("error")}
 
 
+def _attach_leader_env(target: dict[str, Any]) -> None:
+    pane_pid = str(target.get("pane_pid") or "").strip()
+    if not pane_pid:
+        target["leader_env"] = None
+        return
+    env = _read_process_env(pane_pid)
+    if env is None:
+        target["leader_env"] = None
+        return
+    leader_env = {key: env[key] for key in _LEADER_ENV_KEYS if key in env}
+    if "TEAM_AGENT_LEADER_SESSION_UUID" not in leader_env:
+        for child_pid in _walk_leader_shaped_children(pane_pid):
+            child_env = _read_process_env(child_pid)
+            if child_env is None:
+                continue
+            for key in _LEADER_ENV_KEYS:
+                if key not in leader_env and key in child_env:
+                    leader_env[key] = child_env[key]
+            if "TEAM_AGENT_LEADER_SESSION_UUID" in leader_env:
+                break
+    target["leader_env"] = leader_env
+    uuid_value = leader_env.get("TEAM_AGENT_LEADER_SESSION_UUID")
+    if uuid_value:
+        target["leader_session_uuid"] = uuid_value
+
+
+def _read_process_env(pid: str) -> dict[str, str] | None:
+    if platform.system() == "Linux":
+        return _read_proc_environ(pid)
+    return _read_ps_eww_env(pid)
+
+
+def _read_proc_environ(pid: str) -> dict[str, str] | None:
+    path = Path(f"/proc/{pid}/environ")
+    try:
+        raw = path.read_bytes()
+    except (FileNotFoundError, PermissionError, OSError):
+        return None
+    env: dict[str, str] = {}
+    for token in raw.split(b"\x00"):
+        if not token or b"=" not in token:
+            continue
+        try:
+            text = token.decode("utf-8", errors="replace")
+        except Exception:
+            continue
+        key, _, value = text.partition("=")
+        env[key] = value
+    return env
+
+
+def _read_ps_eww_env(pid: str) -> dict[str, str] | None:
+    try:
+        proc = _run_subprocess(
+            ["ps", "-E", "-ww", "-p", str(pid)],
+            text=True,
+            capture_output=True,
+            timeout=_PANE_ENV_SCAN_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return None
+    if proc.returncode != 0 or not proc.stdout:
+        return None
+    return _parse_ps_eww_output(proc.stdout, pid)
+
+
+def _parse_ps_eww_output(text: str, pid: str) -> dict[str, str]:
+    env: dict[str, str] = {}
+    lines = text.splitlines()
+    if len(lines) < 2:
+        return env
+    target_row = None
+    for line in lines[1:]:
+        stripped = line.lstrip()
+        if stripped.split(" ", 1)[0] == str(pid):
+            target_row = stripped
+            break
+    if target_row is None:
+        # Spark MEDIUM #2 (da436a3): never fall back to lines[1] — that row may belong to
+        # an unrelated process and would leak its env (incl. another team's
+        # TEAM_AGENT_LEADER_SESSION_UUID) into this pane's leader_env, corrupting rediscovery.
+        return env
+    for token in target_row.split():
+        if "=" not in token:
+            continue
+        key, _, value = token.partition("=")
+        if not key or " " in key:
+            continue
+        if not (key[0].isalpha() or key[0] == "_"):
+            continue
+        if not all(ch.isalnum() or ch == "_" for ch in key):
+            continue
+        env[key] = value
+    return env
+
+
+def _walk_leader_shaped_children(parent_pid: str) -> list[str]:
+    try:
+        proc = _run_subprocess(
+            ["ps", "-o", "pid=,ppid=,comm="],
+            text=True,
+            capture_output=True,
+            timeout=_PANE_ENV_SCAN_TIMEOUT_SECONDS,
+            check=False,
+        )
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return []
+    if proc.returncode != 0 or not proc.stdout:
+        return []
+    return _select_leader_shaped_descendants(proc.stdout, parent_pid)
+
+
+def _select_leader_shaped_descendants(ps_output: str, parent_pid: str) -> list[str]:
+    rows: list[tuple[str, str, str]] = []
+    for line in ps_output.splitlines():
+        parts = line.split()
+        if len(parts) < 3:
+            continue
+        pid, ppid, command = parts[0], parts[1], " ".join(parts[2:])
+        rows.append((pid, ppid, Path(command).name))
+    descendants: set[str] = set()
+    frontier = {str(parent_pid)}
+    while frontier:
+        next_frontier: set[str] = set()
+        for pid, ppid, _ in rows:
+            if ppid in frontier and pid not in descendants:
+                descendants.add(pid)
+                next_frontier.add(pid)
+        frontier = next_frontier
+    return [
+        pid
+        for pid, _, command in rows
+        if pid in descendants and command in _LEADER_SHAPED_COMMANDS
+    ]
+
+
 def contains_inline_secret(value: str) -> bool:
     return (
         _contains_secret_assignment(value)