aline-ai 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

realign/commands/watcher.py

@@ -524,7 +524,6 @@ def watcher_status_command(verbose: bool = False) -> int:
                         "claude": "Claude Code",
                         "codex": "Codex",
                         "gemini": "Gemini",
-                        "antigravity": "Antigravity",
                     }
                     source = source_map.get(session_type, session_type)
 
@@ -583,7 +582,6 @@ def watcher_status_command(verbose: bool = False) -> int:
                         "claude": "Claude Code",
                         "codex": "Codex",
                         "gemini": "Gemini",
-                        "antigravity": "Antigravity",
                     }
                     source = source_map.get(session_type, session_type)
 
@@ -1069,7 +1067,6 @@ def _get_session_tracking_status_batch(
         "claude": registry.get_adapter("claude"),
         "codex": registry.get_adapter("codex"),
         "gemini": registry.get_adapter("gemini"),
-        "antigravity": registry.get_adapter("antigravity"),
     }
 
     def _infer_adapter_name(session_file: Path) -> str:
@@ -1081,9 +1078,6 @@ def _get_session_tracking_status_batch(
             return "codex"
         if ".gemini" in parts:
             return "gemini"
-        # Antigravity "sessions" may be directories with markdown artifacts.
-        if session_file.is_dir():
-            return "antigravity"
         return "unknown"
 
     session_infos = []
@@ -1258,7 +1252,7 @@ def _get_session_tracking_status(session_file: Path, config: ReAlignConfig, db=N
         - committed_turns: int
         - total_turns: int
         - session_id: str
-        - source: str (claude/codex/gemini/antigravity)
+        - source: str (claude/codex/gemini)
         - project_name: str | None
         - last_activity: datetime
         - session_file: Path
@@ -1449,7 +1443,8 @@ def watcher_session_list_command(
             console.print("[yellow]No sessions discovered.[/yellow]")
             console.print("[dim]Sessions are discovered from:[/dim]")
             console.print("[dim]  • Claude Code: ~/.claude/projects/[/dim]")
-            console.print("[dim]  • Codex: ~/.codex/sessions/[/dim]")
+            console.print("[dim]  • Codex (legacy): ~/.codex/sessions/[/dim]")
+            console.print("[dim]  • Codex (isolated): ~/.aline/codex_homes/*/sessions/[/dim]")
             console.print("[dim]  • Gemini: ~/.gemini/tmp/*/chats/[/dim]")
             console.print("[dim]  • Imported shares: Database[/dim]")
             return 0
@@ -1653,16 +1648,9 @@ def watcher_session_list_command(
             ]
 
             if detect_turns:
-                # Handle Antigravity sessions using timestamps as turn counts
                 total_turns = info.get("total_turns") or 0
                 committed_turns = info.get("committed_turns") or 0
-                if info["source"] == "antigravity" or total_turns > 1000000000:
-                    # Normalize display for timestamp-based tracking
-                    norm_total = 1
-                    norm_committed = 1 if committed_turns > 0 else 0
-                    turns_str = f"{norm_committed}/{norm_total}"
-                else:
-                    turns_str = f"{committed_turns}/{total_turns}"
+                turns_str = f"{committed_turns}/{total_turns}"
                 row_data.append(turns_str)
 
             row_data.extend(
@@ -2212,7 +2200,6 @@ def watcher_event_list_command(
 def watcher_event_revise_slack_command(
     input_json: dict,
     instruction: str,
-    provider: str = "auto",
     json_output: bool = False,
 ) -> int:
     """
@@ -2227,7 +2214,6 @@ def watcher_event_revise_slack_command(
             - slack_message: Current Slack message
             - password: Optional password
         instruction: User's revision instructions
-        provider: LLM provider (auto, claude, openai)
         json_output: If True, output JSON (same format as input)
 
     Returns:
@@ -2237,7 +2223,7 @@ def watcher_event_revise_slack_command(
 
     try:
         from ..db import get_database
-        from ..hooks import _invoke_llm, _extract_json_object
+        from ..llm_client import call_llm_cloud
 
         # Extract data from input JSON
         event_id = input_json.get("event_id")
@@ -2258,24 +2244,14 @@ def watcher_event_revise_slack_command(
                 console.print("[red]Error: Missing 'slack_message' in input JSON[/red]")
             return 1
 
-        # Load prompt template
+        # Load optional custom prompt
+        custom_prompt = None
         prompt_path = Path.home() / ".aline" / "prompts" / "slack_share_revise.md"
-        if not prompt_path.exists():
-            # Fallback to example file
-            prompt_path = Path.home() / ".aline" / "prompts" / "slack_share_revise.md.example"
-
-        if not prompt_path.exists():
-            if not json_output:
-                console.print(f"[red]Prompt file not found: {prompt_path}[/red]")
-                console.print("[dim]Run 'aline init' to initialize prompts[/dim]")
-            return 1
-
         try:
-            system_prompt = prompt_path.read_text(encoding="utf-8")
-        except Exception as e:
-            if not json_output:
-                console.print(f"[red]Failed to read prompt file: {e}[/red]")
-            return 1
+            if prompt_path.exists():
+                custom_prompt = prompt_path.read_text(encoding="utf-8").strip()
+        except Exception:
+            pass
 
         # Build event context from input JSON
         context_parts = []
@@ -2286,35 +2262,21 @@ def watcher_event_revise_slack_command(
 
         event_context = "\n".join(context_parts) if context_parts else "No additional context"
 
-        # Construct user prompt
-        user_prompt = f"""**Original Event Context:**
-```
-{event_context}
-```
-
-**Previous Message:**
-```
-{slack_message}
-```
-
-**Revision Request:**
-```
-{instruction}
-```
-"""
-
-        # Call LLM to revise the message
+        # Call cloud LLM to revise the message
         if not json_output:
             console.print(f"→ Revising Slack message for event: [cyan]{event_title}[/cyan]")
-        logger.info(f"Calling LLM to revise Slack message for event {event_id}")
+        logger.info(f"Calling cloud LLM to revise Slack message for event {event_id}")
 
         try:
-            model_name, response_text = _invoke_llm(
-                provider=provider,
-                system_prompt=system_prompt,
-                user_prompt=user_prompt,
-                purpose="revise_slack_message",
-                silent=True,  # Always silent - suppress LLM provider messages
+            model_name, result = call_llm_cloud(
+                task="revise_slack_message",
+                payload={
+                    "event_context": event_context,
+                    "current_message": slack_message,
+                    "revision_instruction": instruction,
+                },
+                custom_prompt=custom_prompt,
+                silent=True,
             )
         except Exception as e:
             if not json_output:
@@ -2322,27 +2284,18 @@ def watcher_event_revise_slack_command(
             logger.error(f"LLM invocation failed: {e}", exc_info=True)
             return 1
 
-        if not response_text:
+        if not result:
             if not json_output:
                 console.print("[red]LLM did not return a response[/red]")
             logger.error("LLM returned empty response")
             return 1
 
-        # Parse JSON response to extract the revised message
-        try:
-            parsed = _extract_json_object(response_text)
-            if isinstance(parsed, dict) and "message" in parsed:
-                revised_message = parsed["message"]
-            else:
-                # Fallback: use the raw response if JSON parsing fails or no message field
-                revised_message = response_text
-                logger.warning(
-                    "Response did not contain expected 'message' field, using raw response"
-                )
-        except Exception as e:
-            # Fallback: use the raw response if JSON parsing fails
-            revised_message = response_text
-            logger.warning(f"Failed to parse JSON response: {e}, using raw response")
+        revised_message = result.get("message", "")
+        if not revised_message:
+            if not json_output:
+                console.print("[red]LLM response missing 'message' field[/red]")
+            logger.error("LLM response missing 'message' field")
+            return 1
 
         # Update the event in the database
         db = get_database()
@@ -3201,8 +3154,7 @@ def watcher_session_show_command(
                 "claude": "Claude Code",
                 "codex": "Codex",
                 "gemini": "Gemini",
-                "antigravity": "Antigravity",
-            }
+                }
             source = source_map.get(info["source"], info["source"])
 
             # Build turns data
@@ -3301,7 +3253,6 @@ def watcher_session_show_command(
             "claude": "Claude Code",
             "codex": "Codex",
             "gemini": "Gemini",
-            "antigravity": "Antigravity",
         }
         source = source_map.get(info["source"], info["source"])
 
@@ -3662,7 +3613,6 @@ def watcher_session_delete_command(
             "claude": "Claude Code",
             "codex": "Codex",
             "gemini": "Gemini",
-            "antigravity": "Antigravity",
         }
         source = source_map.get(info.get("source", ""), info.get("source", "unknown"))
 

realign/config.py

@@ -20,7 +20,6 @@ class ReAlignConfig:
     auto_detect_claude: bool = True  # Enable Claude Code session auto-detection
     auto_detect_codex: bool = True  # Enable Codex session auto-detection
     auto_detect_gemini: bool = True  # Enable Gemini CLI session auto-detection
-    auto_detect_antigravity: bool = False  # Enable Antigravity IDE brain artifact monitoring
     mcp_auto_commit: bool = True  # Enable watcher auto-commit after each user request completes
     enable_temp_turn_titles: bool = True  # Generate temporary turn titles on user prompt submit
     share_backend_url: str = (
@@ -34,16 +33,9 @@ class ReAlignConfig:
     # Session catch-up settings
     max_catchup_sessions: int = 3  # Max sessions to auto-import on watcher startup
 
-    # LLM API Keys
-    anthropic_api_key: Optional[str] = None  # Anthropic API key (set in config, not environment)
-    openai_api_key: Optional[str] = None  # OpenAI API key (set in config, not environment)
-
-    # LLM Model Configuration
-    llm_anthropic_model: str = "claude-3-5-haiku-20241022"  # Claude model to use
-    llm_openai_model: str = "gpt-4o-mini"  # OpenAI model to use
-    llm_openai_use_responses: bool = False  # Use OpenAI Responses API for reasoning models
-    llm_max_tokens: int = 1000  # Default max tokens
-    llm_temperature: float = 0.0  # Default temperature (0.0 = deterministic)
+    # Terminal auto-close settings
+    auto_close_stale_terminals: bool = False  # Auto-close terminals inactive for 24+ hours
+    stale_terminal_hours: int = 24  # Hours of inactivity before auto-closing
 
     @classmethod
     def load(cls, config_path: Optional[Path] = None) -> "ReAlignConfig":
@@ -87,38 +79,29 @@ class ReAlignConfig:
             "auto_detect_claude": os.getenv("REALIGN_AUTO_DETECT_CLAUDE"),
             "auto_detect_codex": os.getenv("REALIGN_AUTO_DETECT_CODEX"),
             "auto_detect_gemini": os.getenv("REALIGN_AUTO_DETECT_GEMINI"),
-            "auto_detect_antigravity": os.getenv("REALIGN_AUTO_DETECT_ANTIGRAVITY"),
             "mcp_auto_commit": os.getenv("REALIGN_MCP_AUTO_COMMIT"),
             "enable_temp_turn_titles": os.getenv("REALIGN_ENABLE_TEMP_TURN_TITLES"),
             "share_backend_url": os.getenv("REALIGN_SHARE_BACKEND_URL"),
             "user_name": os.getenv("REALIGN_USER_NAME"),
             "uid": os.getenv("REALIGN_UID"),
             "max_catchup_sessions": os.getenv("REALIGN_MAX_CATCHUP_SESSIONS"),
-            "anthropic_api_key": os.getenv("REALIGN_ANTHROPIC_API_KEY"),
-            "openai_api_key": os.getenv("REALIGN_OPENAI_API_KEY"),
-            "llm_anthropic_model": os.getenv("REALIGN_ANTHROPIC_MODEL"),
-            "llm_openai_model": os.getenv("REALIGN_OPENAI_MODEL"),
-            "llm_openai_use_responses": os.getenv("REALIGN_OPENAI_USE_RESPONSES"),
-            "llm_max_tokens": os.getenv("REALIGN_LLM_MAX_TOKENS"),
-            "llm_temperature": os.getenv("REALIGN_LLM_TEMPERATURE"),
+            "auto_close_stale_terminals": os.getenv("REALIGN_AUTO_CLOSE_STALE_TERMINALS"),
+            "stale_terminal_hours": os.getenv("REALIGN_STALE_TERMINAL_HOURS"),
         }
 
         for key, value in env_overrides.items():
             if value is not None:
-                if key in ["summary_max_chars", "max_catchup_sessions", "llm_max_tokens"]:
+                if key in ["summary_max_chars", "max_catchup_sessions", "stale_terminal_hours"]:
                     config_dict[key] = int(value)
-                elif key in ["llm_temperature"]:
-                    config_dict[key] = float(value)
                 elif key in [
                     "redact_on_match",
                     "use_LLM",
                     "auto_detect_claude",
                     "auto_detect_codex",
                     "auto_detect_gemini",
-                    "auto_detect_antigravity",
                     "mcp_auto_commit",
                     "enable_temp_turn_titles",
-                    "llm_openai_use_responses",
+                    "auto_close_stale_terminals",
                 ]:
                     config_dict[key] = value.lower() in ("true", "1", "yes")
                 else:
@@ -150,20 +133,14 @@ class ReAlignConfig:
             "auto_detect_claude": self.auto_detect_claude,
             "auto_detect_codex": self.auto_detect_codex,
             "auto_detect_gemini": self.auto_detect_gemini,
-            "auto_detect_antigravity": self.auto_detect_antigravity,
             "mcp_auto_commit": self.mcp_auto_commit,
             "enable_temp_turn_titles": self.enable_temp_turn_titles,
             "share_backend_url": self.share_backend_url,
             "user_name": self.user_name,
             "uid": self.uid,
             "max_catchup_sessions": self.max_catchup_sessions,
-            "anthropic_api_key": self.anthropic_api_key,
-            "openai_api_key": self.openai_api_key,
-            "llm_anthropic_model": self.llm_anthropic_model,
-            "llm_openai_model": self.llm_openai_model,
-            "llm_openai_use_responses": self.llm_openai_use_responses,
-            "llm_max_tokens": self.llm_max_tokens,
-            "llm_temperature": self.llm_temperature,
+            "auto_close_stale_terminals": self.auto_close_stale_terminals,
+            "stale_terminal_hours": self.stale_terminal_hours,
         }
 
         with open(config_path, "w", encoding="utf-8") as f:
@@ -200,7 +177,6 @@ use_LLM: true                    # Whether to use a cloud LLM to generate summar
 llm_provider: "auto"             # LLM provider: "auto" (try Claude then OpenAI), "claude", or "openai"
 auto_detect_claude: true         # Automatically detect Claude Code session directory (~/.claude/projects/)
 auto_detect_codex: true          # Automatically detect Codex session files (~/.codex/sessions/)
-auto_detect_antigravity: false   # Automatically detect Antigravity IDE brain artifacts (~/.gemini/antigravity/brain/)
 mcp_auto_commit: true            # Enable watcher to auto-commit after each user request completes
 enable_temp_turn_titles: true    # Generate temporary turn titles on user prompt submit
 share_backend_url: "https://realign-server.vercel.app"  # Backend URL for interactive share export
@@ -211,19 +187,6 @@ max_catchup_sessions: 3                # Max sessions to auto-import on watcher
                                        # Use 'aline watcher session list' to see all sessions
                                        # Use 'aline watcher session import <id>' to import specific sessions
 
-# LLM API Keys (configured in this file only, NOT from environment variables):
-# anthropic_api_key: "your-anthropic-api-key"  # For Claude (Anthropic)
-# openai_api_key: "your-openai-api-key"        # For OpenAI (GPT)
-# Note: API keys are read ONLY from this config file, not from system environment variables
-# Alternative: Use REALIGN_ANTHROPIC_API_KEY or REALIGN_OPENAI_API_KEY env vars to override
-
-# LLM Model Configuration:
-llm_anthropic_model: "claude-3-5-haiku-20241022"  # Claude model to use
-llm_openai_model: "gpt-4o-mini"                   # OpenAI model to use
-llm_openai_use_responses: false                   # Use OpenAI Responses API for reasoning models (GPT-5+)
-llm_max_tokens: 1000                              # Default max tokens for LLM responses
-llm_temperature: 0.0                              # Default temperature (0.0 = deterministic, 1.0 = creative)
-
 # Secret Detection & Redaction:
 # ReAlign can use detect-secrets to automatically scan for and redact:
 # - API keys, tokens, passwords

realign/dashboard/app.py

@@ -242,10 +242,7 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_next_page()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_next_page()
-        elif active_tab_id == "sessions":
-            self.query_one(SessionsTable).action_next_page()
-        elif active_tab_id == "events":
-            self.query_one(EventsTable).action_next_page()
+        # sessions and events tabs use scrolling instead of pagination
 
     def action_page_prev(self) -> None:
         """Go to previous page in current panel."""
@@ -256,10 +253,7 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_prev_page()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_prev_page()
-        elif active_tab_id == "sessions":
-            self.query_one(SessionsTable).action_prev_page()
-        elif active_tab_id == "events":
-            self.query_one(EventsTable).action_prev_page()
+        # sessions and events tabs use scrolling instead of pagination
 
     def action_switch_view(self) -> None:
         """Switch view in current panel (if supported)."""
@@ -329,20 +323,22 @@ class AlineDashboard(App):
         self.push_screen(ShareImportScreen())
 
     async def action_load_context(self) -> None:
-        """Load selected sessions/events into the active Claude terminal context."""
+        """Load selected sessions/events into the active terminal context (Claude/Codex)."""
         tabbed_content = self.query_one(TabbedContent)
         active_tab_id = tabbed_content.active
 
         try:
             from . import tmux_manager
 
-            context_id = tmux_manager.get_active_claude_context_id()
+            context_id = tmux_manager.get_active_context_id(
+                allowed_providers={"claude", "codex"}
+            )
         except Exception:
             context_id = None
 
         if not context_id:
             self.notify(
-                "No active Claude context found. Use the Terminal tab and select a 'cc' terminal (New cc).",
+                "No active context found. Use the Terminal tab and select a Claude ('cc') or Codex terminal.",
                 title="Load Context",
                 severity="warning",
                 timeout=4,

realign/dashboard/screens/event_detail.py

@@ -364,7 +364,6 @@ class EventDetailScreen(ModalScreen):
                         "claude": "Claude",
                         "codex": "Codex",
                         "gemini": "Gemini",
-                        "antigravity": "Antigravity",
                     }
                     source = source_map.get(session_type, session_type)
                     project = workspace.split("/")[-1] if workspace else "-"
@@ -398,7 +397,6 @@ class EventDetailScreen(ModalScreen):
                         "claude": "Claude",
                         "codex": "Codex",
                         "gemini": "Gemini",
-                        "antigravity": "Antigravity",
                     }
                     source = source_map.get(session_type, session_type)
                     project = str(workspace).split("/")[-1] if workspace else "-"
@@ -533,7 +531,6 @@ class EventDetailScreen(ModalScreen):
             "claude": "Claude",
             "codex": "Codex",
             "gemini": "Gemini",
-            "antigravity": "Antigravity",
         }
         source = source_map.get(
             record_type or "", record_type or session.get("source") or "unknown"

realign/dashboard/screens/session_detail.py

@@ -171,7 +171,6 @@ class SessionDetailScreen(ModalScreen):
             "claude": "Claude",
             "codex": "Codex",
             "gemini": "Gemini",
-            "antigravity": "Antigravity",
         }
         source = source_map.get(session_type or "", session_type or "unknown")
 

realign/dashboard/tmux_manager.py

@@ -516,9 +516,21 @@ def ensure_inner_session() -> bool:
         return False
 
     if _run_inner_tmux(["has-session", "-t", INNER_SESSION]).returncode != 0:
-        if _run_inner_tmux(["new-session", "-d", "-s", INNER_SESSION]).returncode != 0:
+        # Create a stable "home" window so user-created terminals can use names like "zsh"
+        # without always becoming "zsh-2".
+        if (
+            _run_inner_tmux(["new-session", "-d", "-s", INNER_SESSION, "-n", "home"]).returncode
+            != 0
+        ):
             return False
 
+    # Ensure the default/home window stays named "home" (tmux auto-rename would otherwise
+    # change it to "zsh"/"opencode" depending on the last foreground command).
+    try:
+        _ensure_inner_home_window()
+    except Exception:
+        pass
+
     # Dedicated inner server; safe to enable mouse globally there.
     _run_inner_tmux(["set-option", "-g", "mouse", "on"])
 
@@ -537,6 +549,101 @@ def ensure_inner_session() -> bool:
     return True
 
 
+def _ensure_inner_home_window() -> None:
+    """Ensure the inner session has a reserved, non-renaming 'home' window (best-effort)."""
+    if _run_inner_tmux(["has-session", "-t", INNER_SESSION]).returncode != 0:
+        return
+
+    out = (
+        _run_inner_tmux(
+            [
+                "list-windows",
+                "-t",
+                INNER_SESSION,
+                "-F",
+                "#{window_id}\t#{window_index}\t#{window_name}\t#{"
+                + OPT_TERMINAL_ID
+                + "}\t#{"
+                + OPT_PROVIDER
+                + "}\t#{"
+                + OPT_SESSION_TYPE
+                + "}\t#{"
+                + OPT_CONTEXT_ID
+                + "}\t#{"
+                + OPT_CREATED_AT
+                + "}\t#{"
+                + OPT_NO_TRACK
+                + "}",
+            ],
+            capture=True,
+        ).stdout
+        or ""
+    )
+
+    candidates: list[tuple[str, int, str, str, str, str, str, str, str]] = []
+    for line in _parse_lines(out):
+        parts = (line.split("\t", 8) + [""] * 9)[:9]
+        window_id = parts[0]
+        try:
+            window_index = int(parts[1])
+        except Exception:
+            window_index = 9999
+        window_name = parts[2]
+        terminal_id = parts[3]
+        provider = parts[4]
+        session_type = parts[5]
+        context_id = parts[6]
+        created_at = parts[7]
+        no_track = parts[8]
+
+        # Pick an unmanaged window (the default one created by `new-session`) as "home".
+        unmanaged = (
+            not (terminal_id or "").strip()
+            and not (provider or "").strip()
+            and not (session_type or "").strip()
+            and not (context_id or "").strip()
+            and not (created_at or "").strip()
+        )
+        if unmanaged:
+            candidates.append(
+                (
+                    window_id,
+                    window_index,
+                    window_name,
+                    terminal_id,
+                    provider,
+                    session_type,
+                    context_id,
+                    created_at,
+                    no_track,
+                )
+            )
+
+    if not candidates:
+        return
+
+    # Prefer the first window (index 0) if present.
+    candidates.sort(key=lambda t: t[1])
+    window_id = candidates[0][0]
+
+    # Rename to "home" and prevent tmux auto-renaming it based on foreground command.
+    _run_inner_tmux(["rename-window", "-t", window_id, "home"])
+    _run_inner_tmux(["set-option", "-w", "-t", window_id, "automatic-rename", "off"])
+    _run_inner_tmux(["set-option", "-w", "-t", window_id, "allow-rename", "off"])
+
+    # Mark as internal/no-track so UI can hide it.
+    try:
+        set_inner_window_options(
+            window_id,
+            {
+                OPT_NO_TRACK: "1",
+                OPT_CREATED_AT: str(time.time()),
+            },
+        )
+    except Exception:
+        pass
+
+
 def ensure_right_pane(width_percent: int = 50) -> bool:
     """Create the right-side pane (terminal area) if it doesn't exist.
 
@@ -701,6 +808,7 @@ def create_inner_window(
     terminal_id: str | None = None,
     provider: str | None = None,
     context_id: str | None = None,
+    no_track: bool = False,
 ) -> InnerWindow | None:
     if not ensure_right_pane():
         return None
@@ -744,6 +852,10 @@ def create_inner_window(
     opts.setdefault(OPT_SESSION_TYPE, "")
     opts.setdefault(OPT_SESSION_ID, "")
     opts.setdefault(OPT_TRANSCRIPT_PATH, "")
+    if no_track:
+        opts[OPT_NO_TRACK] = "1"
+    else:
+        opts.setdefault(OPT_NO_TRACK, "")
     set_inner_window_options(window_id, opts)
 
     _run_inner_tmux(["select-window", "-t", window_id])
@@ -784,6 +896,16 @@ def clear_attention(window_id: str) -> bool:
 
 def get_active_claude_context_id() -> str | None:
     """Return the active inner tmux window's Claude ALINE_CONTEXT_ID (if any)."""
+    return get_active_context_id(allowed_providers={"claude"})
+
+
+def get_active_codex_context_id() -> str | None:
+    """Return the active inner tmux window's Codex ALINE_CONTEXT_ID (if any)."""
+    return get_active_context_id(allowed_providers={"codex"})
+
+
+def get_active_context_id(*, allowed_providers: set[str] | None = None) -> str | None:
+    """Return the active inner tmux window's ALINE_CONTEXT_ID (optionally filtered by provider)."""
     try:
         windows = list_inner_windows()
     except Exception:
@@ -793,9 +915,12 @@ def get_active_claude_context_id() -> str | None:
     if active is None:
         return None
 
-    is_claude = (active.provider == "claude") or (active.session_type == "claude")
-    if not is_claude:
-        return None
+    if allowed_providers is not None:
+        allowed = {str(p).strip() for p in allowed_providers if str(p).strip()}
+        provider = (active.provider or "").strip()
+        session_type = (active.session_type or "").strip()
+        if provider not in allowed and session_type not in allowed:
+            return None
 
     context_id = (active.context_id or "").strip()
     return context_id or None