@team-agent/installer 0.2.11 → 0.3.0

package/src/team_agent/rust_core.py

@@ -1,327 +0,0 @@
-from __future__ import annotations
-
-import json
-import platform
-import re
-import shutil
-import subprocess
-from pathlib import Path
-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:
-        return Path(configured)
-    local = repo_root() / "crates" / "team-agent-core" / "target" / "debug" / "team-agent-core"
-    if local.exists():
-        return local
-    return None
-
-
-def call_core(command: str, payload: dict[str, Any] | str | None = None) -> dict[str, Any]:
-    binary = core_binary()
-    if not binary:
-        return {"ok": False, "error": "team-agent-core binary not found", "fallback": True}
-    raw = json.dumps(payload, ensure_ascii=False) if isinstance(payload, dict) else (payload or "")
-    proc = subprocess.run(
-        [str(binary), command, "--json"],
-        input=raw,
-        text=True,
-        capture_output=True,
-        timeout=10,
-        check=False,
-    )
-    try:
-        result = json.loads(proc.stdout or "{}")
-    except json.JSONDecodeError:
-        result = {"ok": False, "error": proc.stdout.strip() or proc.stderr.strip()}
-    if proc.returncode != 0:
-        result.setdefault("ok", False)
-        result.setdefault("error", proc.stderr.strip() or "team-agent-core failed")
-    result["engine"] = "rust" if result.get("ok") else "rust_failed"
-    return result
-
-
-def render_message(payload: dict[str, Any]) -> dict[str, Any]:
-    result = call_core("render-message", payload)
-    if result.get("ok"):
-        return result
-    sender = payload.get("from") or payload.get("sender") or "unknown"
-    task_id = payload.get("task_id")
-    content = payload.get("content") or ""
-    token = payload.get("message_id") or "missing"
-    header = f"Team Agent message from {sender}"
-    if task_id:
-        header += f" for {task_id}"
-    return {
-        "ok": True,
-        "text": f"{header}:\n\n{content}\n\n[team-agent-token:{token}]",
-        "token": token,
-        "engine": "python_fallback",
-        "fallback_reason": result.get("error"),
-    }
-
-
-def redact_text(text: str) -> dict[str, Any]:
-    result = call_core("redact", {"text": text})
-    if result.get("ok"):
-        return result
-    redacted = []
-    for chunk in text.split():
-        lower = chunk.lower()
-        if (
-            "api_key" in lower
-            or "apikey" in lower
-            or "token=" in lower
-            or "secret" in lower
-            or lower == "bearer"
-            or chunk.startswith("sk-")
-            or _looks_base64_secret(chunk)
-        ):
-            redacted.append("[REDACTED]")
-        else:
-            redacted.append(chunk)
-    return {"ok": True, "text": " ".join(redacted), "engine": "python_fallback", "fallback_reason": result.get("error")}
-
-
-def validate_profile_metadata(profile: dict[str, Any]) -> dict[str, Any]:
-    result = call_core("validate-profile", profile)
-    if result.get("ok") or result.get("errors"):
-        return result
-    errors: list[str] = []
-    if profile.get("auth_mode") not in {"subscription", "official_api", "compatible_api"}:
-        errors.append("auth_mode must be subscription, official_api, or compatible_api")
-    for field in ["provider", "model", "profile"]:
-        if not profile.get(field):
-            errors.append(f"{field} must not be empty")
-        if contains_inline_secret(str(profile.get(field) or "")):
-            errors.append("profile metadata contains a probable inline secret")
-    return {"ok": not errors, "errors": errors, "engine": "python_fallback", "fallback_reason": result.get("error")}
-
-
-def list_targets() -> dict[str, Any]:
-    result = call_core("list-targets")
-    if result.get("ok"):
-        return result
-    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}\t#{pane_pid}",
-        ],
-        text=True,
-        capture_output=True,
-        timeout=5,
-        check=False,
-    )
-    if proc.returncode != 0:
-        return {"ok": False, "error": proc.stderr.strip() or "tmux list-panes failed", "engine": "python_fallback"}
-    targets = []
-    for line in proc.stdout.splitlines():
-        parts = line.split("\t")
-        if len(parts) not in {8, 9}:
-            continue
-        target = {
-            "pane_id": parts[0],
-            "session_name": parts[1],
-            "window_index": parts[2],
-            "window_name": parts[3],
-            "pane_index": parts[4],
-            "pane_tty": parts[5],
-            "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)
-        or _contains_bearer_secret(value)
-        or any(chunk.startswith("sk-") or _looks_base64_secret(chunk) for chunk in value.split())
-        or value.startswith("sk-")
-        or _looks_base64_secret(value)
-    )
-
-
-def _contains_secret_assignment(value: str) -> bool:
-    for line in value.splitlines():
-        for separator in ("=", ":"):
-            if separator not in line:
-                continue
-            key, raw = line.split(separator, 1)
-            normalized = re.sub(r"[^a-z0-9]", "", key.lower())
-            if normalized not in {"apikey", "token", "secret", "password", "credential"}:
-                continue
-            candidate = raw.strip().strip("'\"")
-            if candidate.startswith("sk-") or len(candidate) >= 8 or _looks_base64_secret(candidate):
-                return True
-    return False
-
-
-def _contains_bearer_secret(value: str) -> bool:
-    return re.search(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]{16,}", value) is not None
-
-
-def _looks_base64_secret(value: str) -> bool:
-    return len(value) >= 32 and re.fullmatch(r"[A-Za-z0-9+/=_-]+", value) is not None

package/src/team_agent/sessions/__init__.py

@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-from team_agent.sessions.capture import (
-    capture_agent_session,
-    capture_missing_sessions,
-    clear_session_capture_fields,
-    copy_session_metadata,
-)
-from team_agent.sessions.inventory import sessions_overview
-from team_agent.sessions.resume import (
-    attach_profile_resume_root,
-    prepare_resume_state,
-    recover_resume_session_from_events,
-)
-
-__all__ = [
-    "attach_profile_resume_root",
-    "capture_agent_session",
-    "capture_missing_sessions",
-    "clear_session_capture_fields",
-    "copy_session_metadata",
-    "prepare_resume_state",
-    "recover_resume_session_from_events",
-    "sessions_overview",
-]

package/src/team_agent/sessions/capture.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from team_agent.errors import RuntimeError as TeamAgentRuntimeError
-from team_agent.events import EventLog
-from team_agent.providers import get_adapter
-from team_agent.state import SESSION_CAPTURE_FIELDS, SESSION_STATE_FIELDS
-
-
-# Stage 7 S6 (2026-05-27): capture_agent_session used to do a single adapter
-# call and silently return None on miss, leaving status='running' workers with
-# session_id=null. Slow worker startups (Codex writing the rollout file a few
-# tenths of a second after window creation) raced this check. We now poll on a
-# small interval inside the caller's timeout_s budget so the adapter's own
-# fast-path call doesn't have to absorb all the latency on its own.
-_CAPTURE_POLL_INTERVAL_SECONDS = 0.05
-
-
-def capture_missing_sessions(
-    workspace: Path,
-    state: dict[str, Any],
-    event_log: EventLog,
-    timeout_s: float,
-    log_miss: bool = True,
-) -> list[str]:
-    captured: list[str] = []
-    for agent_id, agent_state in state.get("agents", {}).items():
-        if agent_state.get("session_id"):
-            continue
-        known_session_ids = {
-            str(item.get("session_id"))
-            for aid, item in state.get("agents", {}).items()
-            if aid != agent_id and item.get("session_id")
-        }
-        # capture_missing_sessions is invoked from coordinator_tick, diagnose,
-        # status, etc. with very short timeouts; a transient miss should NOT
-        # crash those paths. The loud raise contract belongs to direct callers
-        # (e.g. lifecycle start/restart) who own the worker's atomicity.
-        result = capture_agent_session(
-            workspace,
-            agent_id,
-            agent_state,
-            event_log,
-            timeout_s=timeout_s,
-            exclude_session_ids=known_session_ids,
-            raise_on_missed=False,
-        )
-        if result:
-            captured.append(agent_id)
-        elif log_miss:
-            event_log.write(
-                "session.capture_timeout",
-                agent_id=agent_id,
-                provider=agent_state.get("provider"),
-                timeout_s=timeout_s,
-                spawn_cwd=agent_state.get("spawn_cwd"),
-            )
-    return captured
-
-
-def capture_agent_session(
-    workspace: Path,
-    agent_id: str,
-    agent_state: dict[str, Any],
-    event_log: EventLog,
-    timeout_s: float,
-    exclude_session_ids: set[str] | None = None,
-    raise_on_missed: bool = True,
-) -> dict[str, Any] | None:
-    if agent_state.get("session_id"):
-        return None
-    adapter = get_adapter(agent_state["provider"])
-    spawn_context = {
-        "agent_id": agent_id,
-        "cwd": agent_state.get("spawn_cwd") or str(workspace),
-        "spawn_time": agent_state.get("spawned_at") or datetime.now(timezone.utc).isoformat(),
-        "tmux_target": f"{agent_state.get('session_name', '')}:{agent_state.get('window', agent_id)}",
-        "predetermined_session_id": agent_state.get("_pending_session_id"),
-        "exclude_session_ids": sorted(exclude_session_ids or set()),
-        "claude_projects_root": agent_state.get("claude_projects_root"),
-        "auth_mode": agent_state.get("auth_mode"),
-    }
-    deadline = time.monotonic() + max(timeout_s, 0.0)
-    while True:
-        # Pass timeout_s=0 so the adapter does a single fast-path check; the
-        # outer loop owns the polling budget so behaviour stays consistent
-        # whether or not the adapter has its own internal sleep.
-        result = adapter.capture_session_id(agent_id, spawn_context, timeout_s=0)
-        if isinstance(result, dict) and (result.get("session_id") or result.get("rollout_path")):
-            copy_session_metadata(agent_state, result)
-            agent_state.pop("_pending_session_id", None)
-            event_log.write(
-                "session.captured",
-                agent_id=agent_id,
-                provider=agent_state.get("provider"),
-                session_id=agent_state.get("session_id"),
-                rollout_path=agent_state.get("rollout_path"),
-                captured_via=agent_state.get("captured_via"),
-                attribution_confidence=agent_state.get("attribution_confidence"),
-            )
-            return result
-        if time.monotonic() >= deadline:
-            break
-        time.sleep(_CAPTURE_POLL_INTERVAL_SECONDS)
-    # Timeout. Slice 1 atomicity contract: a worker whose status is 'running'
-    # must NEVER be left with session_id=null — that half-state is what made
-    # Mac mini Stage 7 S5/S6 unreproducible and breaks resume on next restart.
-    # Emit a structured attention event so the coordinator/operator sees the
-    # miss, then raise so callers cannot accidentally treat the None as a
-    # silent "no-op". Non-running workers (still starting, paused, stopped)
-    # legitimately have no session yet, so they still get the silent-None
-    # return that existing callers expect.
-    if agent_state.get("status") == "running":
-        event_log.write(
-            "session.capture_required_attention",
-            agent_id=agent_id,
-            provider=agent_state.get("provider"),
-            timeout_s=timeout_s,
-            spawn_cwd=agent_state.get("spawn_cwd"),
-            session_name=agent_state.get("session_name"),
-            window=agent_state.get("window", agent_id),
-        )
-        if raise_on_missed:
-            raise TeamAgentRuntimeError(
-                f"Failed to capture session_id for agent {agent_id}: adapter "
-                f"did not produce a session within {timeout_s}s. Worker is "
-                "running but unidentifiable; this is a Slice 1 atomicity "
-                "violation."
-            )
-    return None
-
-
-def copy_session_metadata(target: dict[str, Any], source: dict[str, Any]) -> None:
-    for key in SESSION_STATE_FIELDS:
-        target[key] = source.get(key)
-
-
-def clear_session_capture_fields(target: dict[str, Any]) -> None:
-    for key in SESSION_CAPTURE_FIELDS:
-        target[key] = None

package/src/team_agent/sessions/inventory.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from team_agent.spec import load_spec
-from team_agent.state import load_runtime_state
-
-
-def sessions_overview(workspace: Path) -> dict[str, Any]:
-    state = load_runtime_state(workspace)
-    spec_path = Path(state.get("spec_path", workspace / "team.spec.yaml"))
-    spec = load_spec(spec_path) if spec_path.exists() else {}
-    tasks = state.get("tasks", [])
-    rows = []
-    for agent in spec.get("agents", []):
-        agent_state = state.get("agents", {}).get(agent["id"], {})
-        last_task = next((task.get("id") for task in reversed(tasks) if task.get("assignee") == agent["id"]), None)
-        rows.append(
-            {
-                "agent_id": agent["id"],
-                "provider": agent.get("provider"),
-                "model": agent.get("model"),
-                "profile": agent.get("profile"),
-                "session_id": agent_state.get("session_id"),
-                "resume_id": agent_state.get("resume_id"),
-                "rollout_path": agent_state.get("rollout_path"),
-                "captured_at": agent_state.get("captured_at"),
-                "captured_via": agent_state.get("captured_via"),
-                "attribution_confidence": agent_state.get("attribution_confidence"),
-                "spawn_cwd": agent_state.get("spawn_cwd"),
-                "context_usage": agent_state.get("context_usage"),
-                "status": agent_state.get("status", "unknown"),
-                "last_task": last_task,
-                "handoff_path": agent_state.get("handoff_path"),
-                "display_target": agent_state.get("display"),
-                "terminal_target": {
-                    "session": state.get("session_name"),
-                    "window": agent_state.get("window", agent["id"]),
-                    "pane": agent_state.get("pane_id"),
-                },
-            }
-        )
-    return {"ok": True, "sessions": rows, "workspace": str(workspace)}

package/src/team_agent/sessions/resume.py

@@ -1,135 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-from team_agent.events import EventLog
-from team_agent.paths import logs_dir
-from team_agent.profiles import prepare_agent_profile_launch
-from team_agent.providers import ResumeUnavailable
-from team_agent.sessions.capture import clear_session_capture_fields, copy_session_metadata
-
-
-def attach_profile_resume_root(workspace: Path, command_agent: dict[str, Any], previous: dict[str, Any]) -> dict[str, Any]:
-    profile_launch = command_agent.get("_provider_profile") or prepare_agent_profile_launch(workspace, command_agent)
-    if not profile_launch:
-        return previous
-    command_agent["_provider_profile"] = profile_launch
-    root = profile_launch.get("claude_projects_root")
-    if not root:
-        return previous
-    prepared = dict(previous)
-    prepared["claude_projects_root"] = root
-    return prepared
-
-
-def prepare_resume_state(
-    workspace: Path,
-    agent_id: str,
-    previous: dict[str, Any],
-    adapter: Any,
-    event_log: EventLog,
-    exclude_session_ids: set[str] | None = None,
-    allow_fresh_on_resume_failure: bool = False,
-) -> dict[str, Any]:
-    prepared = dict(previous)
-    session_id = prepared.get("session_id")
-    if session_id and adapter.session_is_resumable(prepared, workspace):
-        return prepared
-    if session_id:
-        event_log.write(
-            "resume.session_unverified",
-            agent_id=agent_id,
-            provider=prepared.get("provider"),
-            session_id=session_id,
-            captured_via=prepared.get("captured_via"),
-            spawn_cwd=prepared.get("spawn_cwd"),
-        )
-    else:
-        event_log.write(
-            "resume.session_missing_repair_attempt",
-            agent_id=agent_id,
-            provider=prepared.get("provider"),
-            spawn_cwd=prepared.get("spawn_cwd"),
-        )
-    repaired = recover_resume_session_from_events(workspace, agent_id, prepared, adapter, exclude_session_ids or set())
-    if not repaired:
-        repaired = adapter.recover_session_id(agent_id, prepared, workspace, exclude_session_ids or set())
-    if repaired:
-        copy_session_metadata(prepared, repaired)
-        event_log.write(
-            "resume.session_repaired",
-            agent_id=agent_id,
-            provider=prepared.get("provider"),
-            old_session_id=session_id,
-            session_id=prepared.get("session_id"),
-            rollout_path=prepared.get("rollout_path"),
-            captured_via=prepared.get("captured_via"),
-            attribution_confidence=prepared.get("attribution_confidence"),
-        )
-        return prepared
-    if session_id and not allow_fresh_on_resume_failure:
-        event_log.write(
-            "resume.session_required_missing",
-            agent_id=agent_id,
-            provider=prepared.get("provider"),
-            old_session_id=session_id,
-            rollout_path=prepared.get("rollout_path"),
-            reason="provider transcript not found",
-        )
-        raise ResumeUnavailable(
-            f"Cannot resume agent {agent_id}: stored session {session_id} is not available. "
-            "Use --allow-fresh only if losing that worker context is acceptable."
-        )
-    clear_session_capture_fields(prepared)
-    event_log.write(
-        "resume.session_unavailable",
-        agent_id=agent_id,
-        provider=prepared.get("provider"),
-        old_session_id=session_id,
-        reason="provider transcript not found",
-    )
-    return prepared
-
-
-def recover_resume_session_from_events(
-    workspace: Path,
-    agent_id: str,
-    previous: dict[str, Any],
-    adapter: Any,
-    exclude_session_ids: set[str],
-) -> dict[str, Any] | None:
-    events_path = logs_dir(workspace) / "events.jsonl"
-    try:
-        lines = events_path.read_text(encoding="utf-8").splitlines()
-    except OSError:
-        return None
-    current_session_id = str(previous.get("session_id") or "")
-    for line in reversed(lines):
-        try:
-            event = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        if event.get("agent_id") != agent_id:
-            continue
-        if event.get("event") == "discard.session_tombstone":
-            return None
-        if event.get("event") != "session.captured":
-            continue
-        session_id = str(event.get("session_id") or "")
-        if not session_id or session_id == current_session_id or session_id in exclude_session_ids:
-            continue
-        candidate = dict(previous)
-        candidate.update(
-            {
-                "session_id": session_id,
-                "rollout_path": event.get("rollout_path"),
-                "captured_at": event.get("ts"),
-                "captured_via": "event_log_repair",
-                "attribution_confidence": event.get("attribution_confidence"),
-            }
-        )
-        if adapter.session_is_resumable(candidate, workspace):
-            return candidate
-    return None