@team-agent/installer 0.2.7 → 0.2.9

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,7 +362,7 @@ 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)
@@ -376,7 +378,7 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
             old_session_name=(stale or {}).get("session_name") if isinstance(stale, dict) else None,
             source="restart",
         )
-        save_runtime_state(workspace, state)
+        _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)
@@ -385,6 +387,15 @@ def restart(workspace: Path, allow_fresh: bool = False, team: str | None = None)
     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"