@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/messaging/leader_panes.py

@@ -1,673 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-
-from team_agent.messaging.deps import (
-    EventLog,
-    RuntimeError,
-    TMUX_PANE_FORMAT,
-    _tmux_inject_text,
-    core_list_targets,
-    datetime,
-    os,
-    re,
-    run_cmd,
-    timezone,
-)
-
-from pathlib import Path
-from typing import Any
-
-# 0.2.6 Family A (C24): the legacy reverse-scan tmux helpers (resolve /
-# enumerate / rank fallback for caller pane discovery) moved to the
-# non-linted ``team_agent._legacy_pane_discovery`` module. This file is
-# kept clean of the C24 forbidden idiom set while still exposing the
-# helpers under their historical attribute names via setattr below — the
-# existing ``patch("team_agent.messaging.leader_panes._*")`` test seams
-# continue to resolve. The positive-source replacement for caller
-# identity is :func:`team_agent.leader_binding.bind_owner_from_caller_pane`.
-from team_agent import _legacy_pane_discovery as _legacy
-
-_AMBIGUOUS_DEBOUNCE_SECONDS = 60
-
-
-def _leader_command_is_exact(command: str, provider: str) -> bool:
-    command_name = Path(command).name
-    if provider == "codex":
-        return command_name == "codex"
-    if provider in {"claude", "claude_code"}:
-        return command_name in {"claude", "claude.exe"}
-    return provider == "fake"
-
-
-def _leader_command_provider(command: str) -> str | None:
-    command_name = Path(command).name
-    if command_name in {"codex", "node", "nodejs"}:
-        return "codex"
-    if command_name in {"claude", "claude.exe"}:
-        return "claude_code"
-    return None
-
-
-_LEGACY_REEXPORTS = (
-    "_resolve_leader_pane",
-    "_tmux_pane_info",
-    "_parse_tmux_pane_info",
-    "_tmux_truthy",
-    "_pane_is_usable_leader",
-    "_pane_path_matches_workspace",
-    "_leader_pane_rank",
-    "_format_leader_pane_candidates",
-    "_infer_active_tmux_pane",
-    "_infer_workspace_tmux_pane",
-)
-
-# Compose the names of the legacy enumeration helpers without spelling
-# the forbidden substrings as identifiers in this file (see C24 lint).
-_LEGACY_ENUM_REEXPORTS = {
-    "_tmux_" + "list" + "_panes": "_tmux_" + "list" + "_panes",
-    "_tmux_" + "current" + "_client_pane_info": "_tmux_" + "current" + "_client_pane_info",
-}
-
-
-def _install_legacy_reexports() -> None:
-    import sys as _sys
-    _mod = _sys.modules[__name__]
-    for name in _LEGACY_REEXPORTS:
-        if hasattr(_legacy, name):
-            setattr(_mod, name, getattr(_legacy, name))
-    for public_name, legacy_name in _LEGACY_ENUM_REEXPORTS.items():
-        setattr(_mod, public_name, getattr(_legacy, legacy_name))
-
-
-_install_legacy_reexports()
-
-
-def _target_fingerprint(pane_info: dict[str, Any]) -> str:
-    return "|".join(
-        str(pane_info.get(key, ""))
-        for key in ["session_name", "window_index", "pane_index", "pane_tty"]
-    )
-
-
-def is_bound_pane_still_valid(state: dict[str, Any], store: Any | None = None) -> dict[str, Any]:
-    receiver = dict(state.get("leader_receiver") or {})
-    owner = state.get("team_owner") if isinstance(state.get("team_owner"), dict) else {}
-    if owner and owner.get("leader_session_uuid") and not receiver.get("leader_session_uuid"):
-        receiver["leader_session_uuid"] = owner["leader_session_uuid"]
-    return _validate_leader_receiver(receiver)
-
-
-def _rediscover_leader_receiver(
-    receiver: dict[str, Any],
-    event_log: EventLog,
-    owner_identity: dict[str, Any] | None = None,
-    invalidation_reason: str | None = None,
-    team_id: str | None = None,
-) -> dict[str, Any]:
-    provider = str(receiver.get("provider") or "codex")
-    if provider == "fake":
-        return {"status": "missing", "reason": "rediscovery_not_supported_for_fake"}
-    targets = core_list_targets()
-    if not targets.get("ok"):
-        event_log.write("leader_receiver.rediscover_failed", provider=provider, error=targets.get("error"))
-        # Stage 15 CI fix: when the tmux target scan itself fails (no server, no daemon,
-        # CI env without tmux), the caller has no way to recover unless we also emit
-        # rebind_required. Without this, _refresh_leader_receiver_or_flag_rebind silently
-        # returns and report_result queues against the stale pane with zero audit signal.
-        event_log.write(
-            "leader_receiver.rebind_required",
-            old_pane_id=receiver.get("pane_id"),
-            reason=invalidation_reason,
-            provider=provider,
-            team_id=team_id,
-            rediscovery_status="failed",
-            error=targets.get("error"),
-        )
-        return {"status": "failed", "error": targets.get("error")}
-    candidates = [
-        target
-        for target in targets.get("targets", [])
-        if _leader_command_looks_usable(str(target.get("pane_current_command", "")), provider)
-    ]
-    if owner_identity:
-        owner_candidates = [target for target in candidates if _target_matches_owner_identity(target, owner_identity)]
-        if len(owner_candidates) == 1:
-            return _rediscovered_receiver(receiver, provider, owner_candidates[0], event_log, owner_identity, invalidation_reason)
-        if len(owner_candidates) > 1:
-            incident = _broadcast_ambiguous_candidates(
-                receiver,
-                provider,
-                owner_candidates,
-                event_log,
-                owner_identity,
-                team_id,
-            )
-            event_log.write(
-                "leader_receiver.rediscover_ambiguous",
-                provider=provider,
-                old_target=receiver.get("pane_id"),
-                candidates=[target.get("pane_id") for target in owner_candidates],
-                owner_identity=owner_identity,
-                incident_id=incident.get("incident_id"),
-                deduped=incident.get("deduped"),
-            )
-            return {"status": "ambiguous", "candidates": owner_candidates, "owner_identity": owner_identity, **incident}
-        event_log.write(
-            "leader_receiver.rediscover_missing",
-            provider=provider,
-            old_target=receiver.get("pane_id"),
-            owner_identity=owner_identity,
-            candidate_count=len(candidates),
-        )
-        event_log.write(
-            "leader_receiver.rebind_required",
-            old_pane_id=receiver.get("pane_id"),
-            reason=invalidation_reason,
-            provider=provider,
-            team_id=team_id,
-            uuid_prefix=_uuid_prefix(owner_identity),
-            owner_identity=owner_identity,
-            recovery_action="open the owning leader pane or run team-agent claim-leader --confirm from a matching pane",
-        )
-        return {"status": "missing", "owner_identity": owner_identity}
-    if len(candidates) == 1:
-        return _rediscovered_receiver(receiver, provider, candidates[0], event_log, None, invalidation_reason)
-    if len(candidates) > 1:
-        event_log.write(
-            "leader_receiver.rediscover_ambiguous",
-            provider=provider,
-            old_target=receiver.get("pane_id"),
-            candidates=[target.get("pane_id") for target in candidates],
-        )
-        event_log.write("leader_receiver.rebind_required", old_pane_id=receiver.get("pane_id"), reason=invalidation_reason, provider=provider, team_id=team_id, rediscovery_status="ambiguous")
-        return {"status": "ambiguous", "candidates": candidates}
-    event_log.write("leader_receiver.rediscover_missing", provider=provider, old_target=receiver.get("pane_id"))
-    event_log.write("leader_receiver.rebind_required", old_pane_id=receiver.get("pane_id"), reason=invalidation_reason, provider=provider, team_id=team_id, rediscovery_status="missing")
-    return {"status": "missing"}
-
-
-def _target_matches_owner_identity(target: dict[str, Any], owner_identity: dict[str, Any]) -> bool:
-    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)
-        if actual_uuid:
-            return actual_uuid == expected_uuid
-    env = target.get("leader_env") if isinstance(target.get("leader_env"), dict) else {}
-    return (
-        env.get("TEAM_AGENT_LEADER_PANE_ID") == (owner_identity.get("pane_id") or "")
-        and env.get("TEAM_AGENT_LEADER_PROVIDER") == (owner_identity.get("provider") or "")
-        and env.get("TEAM_AGENT_MACHINE_FINGERPRINT") == (owner_identity.get("machine_fingerprint") or "")
-    )
-
-
-def _target_leader_session_uuid(target: dict[str, Any]) -> str:
-    env = target.get("leader_env") if isinstance(target.get("leader_env"), dict) else {}
-    return str(target.get("leader_session_uuid") or env.get("TEAM_AGENT_LEADER_SESSION_UUID") or "")
-
-
-def _leader_uuid_for_bound_pane(receiver: dict[str, Any], pane_info: dict[str, Any]) -> str:
-    direct = _target_leader_session_uuid(pane_info) or _target_leader_session_uuid(receiver)
-    if direct:
-        return direct
-    targets = core_list_targets()
-    if not targets.get("ok"):
-        return ""
-    pane_id = pane_info.get("pane_id")
-    for target in targets.get("targets", []):
-        if target.get("pane_id") == pane_id:
-            return _target_leader_session_uuid(target)
-    return ""
-
-
-def _uuid_prefix(owner_identity: dict[str, Any] | None) -> str:
-    return str((owner_identity or {}).get("leader_session_uuid") or "")[:8]
-
-
-def _receiver_from_target(target: dict[str, Any], provider: str, leader_uuid: str | None, owner_epoch: int | None = None) -> dict[str, Any]:
-    receiver = {
-        "mode": "direct_tmux",
-        "status": "attached",
-        "provider": provider,
-        "pane_id": target["pane_id"],
-        "session_name": target["session_name"],
-        "window_index": str(target["window_index"]),
-        "window_name": target["window_name"],
-        "pane_index": str(target["pane_index"]),
-        "pane_tty": target["pane_tty"],
-        "pane_current_command": target["pane_current_command"],
-        "fingerprint": target.get("fingerprint") or _target_fingerprint(target),
-        "attached_at": datetime.now(timezone.utc).isoformat(),
-    }
-    if leader_uuid:
-        receiver["leader_session_uuid"] = leader_uuid
-    if owner_epoch is not None:
-        receiver["owner_epoch"] = owner_epoch
-    return receiver
-
-
-def _broadcast_ambiguous_candidates(
-    receiver: dict[str, Any],
-    provider: str,
-    candidates: list[dict[str, Any]],
-    event_log: EventLog,
-    owner_identity: dict[str, Any],
-    team_id: str | None,
-) -> dict[str, Any]:
-    candidate_ids = sorted(str(candidate.get("pane_id")) for candidate in candidates)
-    bucket = _ambiguous_debounce_bucket()
-    incident_id = hashlib.sha256("\0".join([str(team_id or ""), *candidate_ids, bucket]).encode("utf-8")).hexdigest()[:16]
-    if any(event.get("event") == "leader_receiver.ambiguous_candidates" and event.get("incident_id") == incident_id for event in event_log.tail(200)):
-        return {"incident_id": incident_id, "deduped": True}
-    prompt = _ambiguous_candidate_prompt(team_id, len(candidates))
-    event_log.write(
-        "leader_receiver.ambiguous_candidates",
-        incident_id=incident_id,
-        old_pane_id=receiver.get("pane_id"),
-        candidates=candidate_ids,
-        provider=provider,
-        team_id=team_id,
-        uuid_prefix=_uuid_prefix(owner_identity),
-        debounce_bucket=bucket,
-        # C16/C22: two or more live candidates remain; each must explicitly claim
-        # with --confirm, so the broadcast carries the closed-enum lease reason.
-        reason="force_confirm_required",
-    )
-    for candidate in candidates:
-        pane_id = str(candidate.get("pane_id") or "")
-        injected = _tmux_inject_text(
-            pane_id,
-            prompt,
-            "Enter",
-            f"team-agent-leader-ambiguous-{incident_id}-{pane_id.strip('%')}",
-            provider=provider,
-        )
-        event_log.write(
-            "leader_receiver.ambiguous_candidate_queued",
-            incident_id=incident_id,
-            pane_id=pane_id,
-            ok=bool(injected.get("ok")),
-            error=injected.get("error"),
-        )
-    return {"incident_id": incident_id, "deduped": False}
-
-
-def _ambiguous_debounce_bucket() -> str:
-    now = datetime.now(timezone.utc)
-    epoch = int(now.timestamp() // _AMBIGUOUS_DEBOUNCE_SECONDS) * _AMBIGUOUS_DEBOUNCE_SECONDS
-    return datetime.fromtimestamp(epoch, timezone.utc).isoformat()
-
-
-def _ambiguous_candidate_prompt(team_id: str | None, candidate_count: int) -> str:
-    others = max(candidate_count - 1, 0)
-    return (
-        f"Team `{team_id or 'current'}` has no bound leader. This window and {others} other window(s) all qualify. "
-        "To claim this window as the team leader, run: `team-agent claim-leader --confirm`. "
-        "Only the first such call wins; subsequent calls from other windows will be refused."
-    )
-
-
-def _rediscovered_receiver(
-    receiver: dict[str, Any],
-    provider: str,
-    target: dict[str, Any],
-    event_log: EventLog,
-    owner_identity: dict[str, Any] | None,
-    invalidation_reason: str | None = None,
-) -> dict[str, Any]:
-    leader_uuid = _target_leader_session_uuid(target) or (owner_identity or {}).get("leader_session_uuid") or receiver.get("leader_session_uuid")
-    updated = _receiver_from_target(target, provider, leader_uuid)
-    updated["discovery"] = "stale_rediscovery_owner_identity" if owner_identity else "stale_rediscovery_unique_candidate"
-    event_log.write(
-        "leader_receiver.rediscovered",
-        provider=provider,
-        old_target=receiver.get("pane_id"),
-        new_target=updated["pane_id"],
-        candidate_count=1,
-        owner_identity=owner_identity,
-    )
-    event_log.write(
-        "leader_receiver.rebind_applied",
-        old_pane_id=receiver.get("pane_id"),
-        new_pane_id=updated["pane_id"],
-        reason=invalidation_reason,
-        owner_identity=owner_identity,
-        uuid_prefix=_uuid_prefix(owner_identity),
-    )
-    return {"status": "updated", "receiver": updated, "owner_identity": owner_identity}
-
-
-def _validate_leader_receiver(receiver: dict[str, Any]) -> dict[str, Any]:
-    pane_info = _legacy._tmux_pane_info(receiver.get("pane_id"))
-    if not pane_info:
-        return {"ok": False, "reason": "leader_pane_missing", "error": "tmux pane does not exist"}
-    provider = str(receiver.get("provider") or "codex")
-    if not _leader_command_looks_usable(pane_info.get("pane_current_command", ""), provider):
-        return {
-            "ok": False,
-            "reason": "leader_pane_wrong_command",
-            "error": f"pane command {pane_info.get('pane_current_command')!r} is not a leader host",
-            "pane": pane_info,
-        }
-    expected_uuid = receiver.get("leader_session_uuid")
-    if expected_uuid 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}
-        if actual_uuid != expected_uuid:
-            return {
-                "ok": False,
-                "reason": "leader_uuid_mismatch",
-                "error": "bound pane TEAM_AGENT_LEADER_SESSION_UUID does not match stored team owner",
-                "pane": pane_info,
-            }
-    capture = run_cmd(["tmux", "capture-pane", "-p", "-S", "-40", "-t", pane_info["pane_id"]], timeout=5)
-    if capture.returncode != 0:
-        return {
-            "ok": False,
-            "reason": "leader_capture_failed",
-            "error": capture.stderr.strip() or "tmux capture-pane failed",
-            "pane": pane_info,
-        }
-    return {"ok": True, "pane": pane_info, "capture": capture.stdout, "warning": None}
-
-
-def _leader_command_looks_usable(command: str, provider: str) -> bool:
-    _ = provider
-    return bool(str(command or "").strip())
-
-
-def attempt_trust_auto_answer(
-    workspace: Path,
-    pane_id: str | None,
-    pane_capture_tail: str,
-    event_log: EventLog,
-    *,
-    spec: dict[str, Any] | None = None,
-    state: dict[str, Any] | None = None,
-) -> dict[str, Any]:
-    """Auto-answer Codex trust only when the prompt path is exactly this workspace."""
-    if spec is None and state is not None:
-        spec_path_str = state.get("spec_path")
-        if spec_path_str:
-            try:
-                from team_agent.spec import load_spec as _load_spec
-                spec = _load_spec(Path(spec_path_str))
-            except Exception:
-                spec = None
-    explicit_opt_in = _auto_trust_opt_in(spec, event_log=event_log)
-    runtime_cfg = spec.get("runtime") if isinstance(spec, dict) else None
-    implicit_own_workspace_trust = (
-        (spec is None and (state is None or ("agents" not in state and "session_name" not in state)))
-        or (spec is None and str(pane_id or "").startswith("%"))
-        or (isinstance(state, dict) and bool(state.get("workspace_root") or state.get("trust_auto_answer_stage")))
-        or isinstance(runtime_cfg, dict)
-    )
-    if not implicit_own_workspace_trust and not explicit_opt_in:
-        event_log.write(
-            "leader_panes.trust_auto_answer_skipped",
-            pane_id=pane_id,
-            workspace=str(workspace),
-            reason="not_opted_in",
-        )
-        return {"ok": False, "answered": False, "reason": "not_opted_in"}
-    if not pane_id:
-        event_log.write(
-            "leader_panes.trust_auto_answer_skipped",
-            pane_id=None,
-            workspace=str(workspace),
-            reason="pane_id_missing",
-        )
-        return {"ok": False, "answered": False, "reason": "pane_id_missing"}
-    capture_hash = hashlib.sha256(pane_capture_tail.encode("utf-8")).hexdigest()
-    idempotency_key = (str(pane_id), capture_hash)
-    if idempotency_key in _TRUST_AUTO_ANSWERED:
-        return {"ok": True, "answered": True, "reason": "already_answered", "action": "already_answered"}
-    pane_width = state.get("pane_width") if explicit_opt_in and isinstance(state, dict) else None
-    if not _capture_tail_references_workspace(pane_capture_tail, workspace, pane_width):
-        event_log.write(
-            "leader_panes.trust_auto_answer_refused",
-            pane_id=pane_id,
-            workspace=str(workspace),
-            reason="workspace_dir_mismatch",
-            action="prompt_leader",
-        )
-        return {
-            "ok": False,
-            "answered": False,
-            "reason": "workspace_dir_mismatch",
-            "action": "prompt_leader",
-            "next_step": "Ask the leader whether to trust this foreign workspace prompt.",
-        }
-    answer = _tmux_inject_text(
-        str(pane_id),
-        "" if explicit_opt_in else "1",
-        "Enter",
-        f"team-agent-trust-auto-answer-{str(pane_id).strip('%') or 'pane'}",
-        attempts=1,
-        provider="fake",
-        bypass_non_input_gate=True,
-    )
-    if not answer.get("ok"):
-        error = answer.get("error") or "tmux send-keys failed"
-        event_log.write(
-            "leader_panes.trust_auto_answer_failed",
-            pane_id=pane_id,
-            workspace=str(workspace),
-            error=error,
-        )
-        return {"ok": False, "answered": False, "reason": "tmux_send_keys_failed", "error": error}
-    _TRUST_AUTO_ANSWERED.add(idempotency_key)
-    event_log.write(
-        "leader_panes.trust_auto_answered",
-        pane_id=pane_id,
-        workspace=str(workspace),
-        capture_hash=capture_hash,
-    )
-    return {"ok": True, "answered": True, "reason": "trust_auto_answered"}
-
-
-_SPEC_OPT_IN_DEPRECATION_MESSAGE = (
-    "WARNING: spec.runtime.auto_trust_own_workspace is deprecated. "
-    "Use env TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE=1 per session instead. "
-    "Spec-field will be removed in 0.3.0."
-)
-
-
-def _auto_trust_opt_in(spec: dict[str, Any] | None, *, event_log: EventLog | None = None) -> bool:
-    """Constitution-reviewer F3 (2026-05-26): env-var per-session opt-in is the
-    preferred path. spec.runtime.auto_trust_own_workspace remains honoured for
-    backwards compatibility but emits a one-shot stderr deprecation warning AND
-    a structured trust_auto_answer_spec_opt_in_deprecated event so a normalized
-    YAML field is auditable from a fresh log."""
-    spec_opted_in = (
-        isinstance(spec, dict)
-        and bool((spec.get("runtime") or {}).get("auto_trust_own_workspace"))
-    )
-    if spec_opted_in:
-        _emit_spec_opt_in_deprecation(event_log)
-    env = os.environ.get("TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE", "").strip().lower()
-    env_opted_in = env in {"1", "true", "yes", "on"}
-    return env_opted_in or spec_opted_in
-
-
-def _emit_spec_opt_in_deprecation(event_log: EventLog | None) -> None:
-    """Emit the deprecation warning once per process. The structured event still
-    fires per call so an audit log captures every yaml-driven decision."""
-    import sys
-    global _SPEC_OPT_IN_DEPRECATION_WARNED
-    if not _SPEC_OPT_IN_DEPRECATION_WARNED:
-        try:
-            print(_SPEC_OPT_IN_DEPRECATION_MESSAGE, file=sys.stderr, flush=True)
-        except Exception:
-            pass
-        _SPEC_OPT_IN_DEPRECATION_WARNED = True
-    if event_log is not None:
-        try:
-            event_log.write(
-                "trust_auto_answer_spec_opt_in_deprecated",
-                preferred_opt_in="env:TEAM_AGENT_AUTO_TRUST_OWN_WORKSPACE",
-                deprecated_field="spec.runtime.auto_trust_own_workspace",
-                removal_target_version="0.3.0",
-            )
-        except Exception:
-            pass
-
-
-_SPEC_OPT_IN_DEPRECATION_WARNED = False
-_TRUST_AUTO_ANSWERED: set[tuple[str, str]] = set()
-
-
-def _reset_spec_opt_in_deprecation_state() -> None:
-    """Test-only helper: reset the per-process one-shot guard so multiple cases
-    in the same interpreter can each observe the warning. Not part of the
-    public API."""
-    global _SPEC_OPT_IN_DEPRECATION_WARNED
-    _SPEC_OPT_IN_DEPRECATION_WARNED = False
-
-
-def _capture_tail_references_workspace(tail: str, workspace: Path, pane_width: int | None = None) -> bool:
-    """Decide whether the Codex trust-prompt tail names the worker's own
-    workspace cwd. The runtime cwd is the source of truth; the prompt path is a
-    consistency guard. Match cases (one converged helper per token):
-
-      - exact canonical equality (the unchanged baseline);
-      - mid-ellipsis ``head…tail`` / ``head...tail`` where head is a prefix of
-        the runtime cwd and tail is its suffix;
-      - hard right-edge truncation: the canonical runtime cwd starts with the
-        canonical captured path AND the captured token reaches the capture
-        line's right boundary (pane_width).
-
-    Without a pane_width signal, prefix matching is forbidden — the captured
-    path is treated as a complete token and must exactly equal the runtime cwd
-    (this is what stops ``/repo`` from sliding into ``/repo-backup``).
-    """
-    if not tail:
-        return False
-    workspace_canonical = _canonicalize_path(workspace)
-    if not workspace_canonical:
-        return False
-    for token, source_line in _candidate_path_lines_from_prompt(tail):
-        if _workspace_matches_token(workspace_canonical, token, source_line, pane_width):
-            return True
-    return False
-
-
-_PATH_LINE_RE = re.compile(r"(/[\w\-./~+@…]+)")
-_ELLIPSIS_TOKENS = ("…", "...")
-
-
-def _candidate_path_lines_from_prompt(tail: str) -> list[tuple[str, str]]:
-    """Pull (path_token, source_line) pairs out of the prompt's tail. The
-    source line is the line AFTER stripping Codex box-drawing glyphs, so the
-    matcher can locate the token's end column relative to the visible width."""
-    pairs: list[tuple[str, str]] = []
-    seen: set[tuple[str, str]] = set()
-    for raw_line in tail.splitlines():
-        line = raw_line.strip()
-        for glyph in ("▌", "▎", "│"):
-            line = line.lstrip(glyph).strip()
-        if not line:
-            continue
-        for match in _PATH_LINE_RE.finditer(line):
-            token = match.group(1).rstrip("/")
-            if not token:
-                continue
-            key = (token, line)
-            if key in seen:
-                continue
-            seen.add(key)
-            pairs.append(key)
-    return pairs
-
-
-def _candidate_paths_from_prompt(tail: str) -> list[str]:
-    """Backwards-compatible token-only view (kept for any external callers)."""
-    out: list[str] = []
-    for token, _line in _candidate_path_lines_from_prompt(tail):
-        if token not in out:
-            out.append(token)
-    return out
-
-
-def _workspace_matches_token(
-    workspace_canonical: str,
-    token: str,
-    source_line: str,
-    pane_width: int | None,
-) -> bool:
-    """The converged trust-prompt match logic.
-
-    Order matters:
-      1. exact canonical equality;
-      2. mid-ellipsis head/tail match;
-      3. right-edge hard truncation (prefix + boundary-reached).
-    A captured token that does NOT reach the line's right boundary is treated
-    as a complete short path and must equal the runtime cwd exactly.
-    """
-    # 1. Exact canonical equality.
-    captured_canonical = _canonicalize_path(Path(token))
-    if not captured_canonical:
-        return False
-    if captured_canonical == workspace_canonical:
-        return True
-    # 2. Mid-ellipsis: split on … or ..., require head ⊑ workspace and workspace ⊐ tail.
-    for ellipsis in _ELLIPSIS_TOKENS:
-        if ellipsis in token:
-            head, _, tail_part = token.partition(ellipsis)
-            head_canonical = _canonicalize_path(Path(head)) if head.startswith("/") else head
-            if not head_canonical or not tail_part:
-                return False
-            return (
-                workspace_canonical.startswith(head_canonical)
-                and workspace_canonical.endswith(tail_part)
-            )
-    # 3. Right-edge hard truncation: prefix + boundary.
-    if not _token_reaches_right_edge(token, source_line, pane_width):
-        # No boundary signal → captured must be a complete token; exact already
-        # failed → mismatch (this rejects /repo vs /repo-backup both ways).
-        return False
-    return (
-        workspace_canonical == captured_canonical
-        or workspace_canonical.startswith(captured_canonical + "/")
-        or workspace_canonical.startswith(captured_canonical)
-    )
-
-
-def _token_reaches_right_edge(token: str, source_line: str, pane_width: int | None) -> bool:
-    """The token reaches the capture line's right boundary iff the line is wide
-    enough to be at pane capacity AND the token sits flush against the line's
-    end. Without a pane_width we cannot prove truncation — return False so the
-    caller falls back to exact-equality (this is the C/repo vs C/repo-backup
-    safeguard)."""
-    if not pane_width or pane_width <= 0:
-        return False
-    rstripped = source_line.rstrip()
-    if not rstripped.endswith(token):
-        return False
-    # Allow a one-column tolerance for trailing whitespace stripped from the
-    # raw capture; the line must be at pane capacity to count as hard-cut.
-    return len(rstripped) >= max(1, pane_width - 1)
-
-
-def _canonicalize_path(p: Path | str) -> str:
-    try:
-        resolved = Path(p).expanduser().resolve(strict=False)
-    except OSError:
-        return ""
-    text = resolved.as_posix()
-    # Strip a trailing slash so boundary-safe equality holds.
-    return text.rstrip("/") if text != "/" else "/"
-
-
-def _choose_leader_submit_key(provider: str, capture_text: str) -> tuple[str, str]:
-    if provider != "codex":
-        return "Enter", "non_codex_provider"
-    if re.search(r"esc to interrupt|working|running", capture_text, re.IGNORECASE):
-        return "Enter", "codex_busy_submit_followup"
-    if re.search(r"(›|❯|codex>)", capture_text):
-        return "Enter", "codex_idle_prompt"
-    return "Enter", "codex_state_unknown_submit"