memstack-skill-loader 4.1.1__tar.gz → 4.2.0__tar.gz

{memstack_skill_loader-4.1.1/src/memstack_skill_loader.egg-info → memstack_skill_loader-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memstack-skill-loader
-Version: 4.1.1
+Version: 4.2.0
 Summary: MCP server that vector-indexes MemStack Pro skills for on-demand loading
 Requires-Python: >=3.10
 Requires-Dist: mcp>=1.0.0
@@ -8,3 +8,4 @@ Requires-Dist: lancedb>=0.6.0
 Requires-Dist: sentence-transformers>=2.2.0
 Requires-Dist: pyarrow>=14.0.0
 Requires-Dist: httpx>=0.24.0
+Requires-Dist: aiohttp>=3.9

{memstack_skill_loader-4.1.1 → memstack_skill_loader-4.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memstack-skill-loader"
-version = "4.1.1"
+version = "4.2.0"
 description = "MCP server that vector-indexes MemStack Pro skills for on-demand loading"
 requires-python = ">=3.10"
 dependencies = [
@@ -13,6 +13,7 @@ dependencies = [
     "sentence-transformers>=2.2.0",
     "pyarrow>=14.0.0",
     "httpx>=0.24.0",
+    "aiohttp>=3.9",
 ]
 
 [project.scripts]

{memstack_skill_loader-4.1.1 → memstack_skill_loader-4.2.0}/src/memstack_skill_loader/__init__.py

@@ -1,3 +1,3 @@
 """MemStack Skill Loader — MCP server for semantic skill search."""
 
-__version__ = "4.1.1"
+__version__ = "4.2.0"

{memstack_skill_loader-4.1.1 → memstack_skill_loader-4.2.0}/src/memstack_skill_loader/__main__.py

@@ -78,6 +78,15 @@ def main():
     elif len(sys.argv) > 2 and sys.argv[1] == "run":
         task = " ".join(sys.argv[2:])
         _run_agents(task)
+    elif len(sys.argv) > 1 and sys.argv[1] == "proxy":
+        import argparse
+        parser = argparse.ArgumentParser(prog="memstack proxy")
+        parser.add_argument("--port", type=int, default=8787)
+        parser.add_argument("--host", default="127.0.0.1")
+        parser.add_argument("--verbose", action="store_true", help="Show parser diagnostics")
+        args = parser.parse_args(sys.argv[2:])
+        from .proxy.server import start_proxy
+        start_proxy(host=args.host, port=args.port, verbose=args.verbose)
     elif len(sys.argv) > 1 and sys.argv[1] == "run":
         print("Usage: python -m memstack_skill_loader run \"Your task description\"",
               file=sys.stderr)

{memstack_skill_loader-4.1.1 → memstack_skill_loader-4.2.0}/src/memstack_skill_loader/agent_runner.py

@@ -1,5 +1,5 @@
 # Agent Runner v4.0 - MemStack autonomous agent orchestration
-"""Agent Runner — orchestrates Claude Code agents via --print invocations."""
+"""Agent Runner — orchestrates Claude Code agents via interactive streaming."""
 
 import json
 import os
@@ -14,7 +14,42 @@ from typing import Optional
 
 import httpx
 
-from .stats import log_agent_invocation
+from .stats import log_agent_invocation, log_api_cost
+
+
+# ---------------------------------------------------------------------------
+# Anthropic model pricing (per million tokens, May 2026)
+# ---------------------------------------------------------------------------
+
+MODEL_PRICING = {
+    "claude-sonnet-4-6": {"input": 3.0, "output": 15.0},
+    "claude-opus-4-6": {"input": 5.0, "output": 25.0},
+    "claude-opus-4-7": {"input": 5.0, "output": 25.0},
+    "claude-haiku-4-5": {"input": 1.0, "output": 5.0},
+}
+# Cache read: 90% discount on input rate
+# Cache creation: 25% premium on input rate
+
+
+def _calculate_api_cost(
+    model: str,
+    input_tokens: int,
+    output_tokens: int,
+    cache_read_tokens: int = 0,
+    cache_creation_tokens: int = 0,
+) -> float:
+    """Calculate USD cost from token counts and model pricing."""
+    pricing = MODEL_PRICING.get(model, MODEL_PRICING["claude-sonnet-4-6"])
+    input_rate = pricing["input"]
+    output_rate = pricing["output"]
+
+    cost = (input_tokens / 1_000_000 * input_rate
+            + output_tokens / 1_000_000 * output_rate)
+    if cache_read_tokens > 0:
+        cost += cache_read_tokens / 1_000_000 * input_rate * 0.1
+    if cache_creation_tokens > 0:
+        cost += cache_creation_tokens / 1_000_000 * input_rate * 1.25
+    return round(cost, 6)
 
 
 # ---------------------------------------------------------------------------
@@ -24,18 +59,47 @@ from .stats import log_agent_invocation
 STATE_DIR = Path.home() / ".memstack" / "agent-runner"
 STATE_FILE = STATE_DIR / "state.json"
 
-AGENT_TIMEOUT = 3600  # seconds per --print invocation (default 60 minutes)
+AGENT_TIMEOUT = 3600  # seconds per agent invocation (default 60 minutes)
 MAX_ITERATIONS = 2
 
 ANTHROPIC_BASE_URL = os.environ.get("ANTHROPIC_BASE_URL", "")
 API_KEY_FILE = Path.home() / ".memstack" / "api_key"
+OAUTH_TOKEN_FILE = Path.home() / ".memstack" / "oauth_token"
 API_DEFAULT_MODEL = "claude-sonnet-4-20250514"
 API_MAX_TOKENS = 16000
 
-if not os.environ.get("ANTHROPIC_API_KEY") and API_KEY_FILE.is_file():
-    _stored_key = API_KEY_FILE.read_text(encoding="utf-8").strip()
-    if _stored_key:
-        os.environ["ANTHROPIC_API_KEY"] = _stored_key
+# API key loading moved to _load_api_key() — called on-demand per agent invocation.
+# Do NOT set os.environ["ANTHROPIC_API_KEY"] at module load. It defeats subscription mode.
+
+
+def _load_api_key() -> str | None:
+    """Get the Anthropic API key from environment or stored config file."""
+    key = os.environ.get("ANTHROPIC_API_KEY", "").strip()
+    if key:
+        return key
+    try:
+        if API_KEY_FILE.is_file():
+            stored = API_KEY_FILE.read_text(encoding="utf-8").strip()
+            if stored:
+                return stored
+    except Exception:
+        pass
+    return None
+
+def _load_oauth_token() -> str | None:
+    """Get the OAuth token from environment or stored config file."""
+    token = os.environ.get("CLAUDE_CODE_OAUTH_TOKEN", "").strip()
+    if token:
+        return token
+    try:
+        if OAUTH_TOKEN_FILE.is_file():
+            stored = OAUTH_TOKEN_FILE.read_text(encoding="utf-8").strip()
+            if stored:
+                return stored
+    except Exception:
+        pass
+    return None
+
 
 SYSTEM_PROMPTS = {
     "manager": (
@@ -184,25 +248,50 @@ _VALID_AGENT_MODES = ("api", "subscription")
 
 
 def _default_agent_modes() -> dict:
-    """Return default execution modes based on whether an API key is available."""
-    has_key = bool(os.environ.get("ANTHROPIC_API_KEY") or ANTHROPIC_BASE_URL)
-    if has_key:
-        return {"manager": "api", "builder": "subscription", "reviewer": "api"}
+    """Return default execution modes — always subscription.
+
+    The API key enables the *option* to switch to API mode in the dashboard,
+    but never pre-selects it.
+    """
     return {"manager": "subscription", "builder": "subscription", "reviewer": "subscription"}
 
 
 def load_agent_modes() -> dict:
-    """Load agent execution modes from config, falling back to defaults."""
+    """Load agent execution modes from config, falling back to defaults.
+
+    On first run (no ``_agent_modes`` key in config), the computed defaults
+    are persisted immediately so subsequent loads read an explicit saved state.
+    """
     cfg = load_builder_tools_config()
     stored = cfg.get("_agent_modes", {})
+    first_run = "_agent_modes" not in cfg
     defaults = _default_agent_modes()
     modes = {}
     for agent in ("manager", "builder", "reviewer"):
         val = stored.get(agent, "")
         modes[agent] = val if val in _VALID_AGENT_MODES else defaults[agent]
+    if first_run:
+        save_agent_modes(modes)
     return modes
 
 
+def _load_agent_display_names() -> dict[str, str]:
+    """Load custom agent display names from user profile, falling back to role names."""
+    profile_path = Path.home() / ".memstack" / "user_profile.json"
+    names = {"manager": "manager", "builder": "builder", "reviewer": "reviewer"}
+    try:
+        if profile_path.exists():
+            data = json.loads(profile_path.read_text(encoding="utf-8"))
+            stored = data.get("agent_names", {})
+            for role in names:
+                custom = stored.get(role, "").strip()
+                if custom:
+                    names[role] = custom.lower()
+    except Exception:
+        pass
+    return names
+
+
 def save_agent_modes(modes: dict) -> None:
     """Save agent execution modes to config."""
     cfg = load_builder_tools_config()
@@ -329,22 +418,31 @@ def _extract_commit_from_reviewer(reviewer_output: str) -> str:
 
 
 # ---------------------------------------------------------------------------
-# Agent invocation via --print
+# Agent invocation via interactive streaming
 # ---------------------------------------------------------------------------
 
-def _build_env() -> dict:
+def _build_env(strip_api_key: bool = False, inject_api_key: str | None = None) -> dict:
     """Build environment for subprocess, ensuring Anthropic vars are passed."""
     env = os.environ.copy()
     env.pop("MEMSTACK_ENABLE_TTS", None)
+    # Strip API key for subscription mode so CC uses subscription instead of API.
+    # Set strip_api_key=False to revert.
+    if strip_api_key:
+        env.pop("ANTHROPIC_API_KEY", None)
+        oauth_token = _load_oauth_token()
+        if oauth_token:
+            env["ANTHROPIC_AUTH_TOKEN"] = oauth_token
+    elif inject_api_key:
+        env["ANTHROPIC_API_KEY"] = inject_api_key
     if ANTHROPIC_BASE_URL:
         env["ANTHROPIC_BASE_URL"] = ANTHROPIC_BASE_URL
     return env
 
 
-def _parse_stream_json(raw: str) -> tuple[str, int, int, float, int]:
+def _parse_stream_json(raw: str) -> tuple[str, int, int, float, int, str]:
     """Extract text and token usage from claude --output-format stream-json.
 
-    Returns (text, input_tokens, output_tokens, cost_usd, context_tokens).
+    Returns (text, input_tokens, output_tokens, cost_usd, context_tokens, model).
     context_tokens is the last iteration's total tokens (accurate context window fill).
     """
     text_parts: list[str] = []
@@ -354,6 +452,7 @@ def _parse_stream_json(raw: str) -> tuple[str, int, int, float, int]:
     output_tokens = 0
     cost_usd = 0.0
     context_tokens = 0
+    stream_model = ""
     last_assistant_usage: dict = {}
     for line in raw.splitlines():
         line = line.strip()
@@ -365,6 +464,9 @@ def _parse_stream_json(raw: str) -> tuple[str, int, int, float, int]:
             continue
         msg_type = obj.get("type")
         if msg_type == "assistant":
+            msg_model = obj.get("message", {}).get("model", "")
+            if msg_model:
+                stream_model = msg_model
             usage = obj.get("message", {}).get("usage", {})
             if usage:
                 last_assistant_usage = usage
@@ -399,7 +501,7 @@ def _parse_stream_json(raw: str) -> tuple[str, int, int, float, int]:
         text = "[Agent completed with tool calls but no text summary]\n\n" + "\n\n".join(tool_parts)
     else:
         text = ""
-    return text, input_tokens, output_tokens, cost_usd, context_tokens
+    return text, input_tokens, output_tokens, cost_usd, context_tokens, stream_model
 
 
 def _extract_text_from_stream_line(line: str) -> Optional[str]:
@@ -434,17 +536,18 @@ def _invoke_api_agent(name: str, prompt: str, system_prompt: str,
                       log_path: Optional[Path] = None, timeout: int = 600,
                       model: str = "", session_id: Optional[str] = None,
                       working_dir: str = "",
+                      display_name: str = "",
                       ) -> tuple[str, int, int]:
     """Call the Anthropic Messages API directly via httpx.
 
     Returns (text, input_tokens, output_tokens).
     """
-    api_key = os.environ.get("ANTHROPIC_API_KEY", "")
+    api_key = _load_api_key() or ""
     base_url = ANTHROPIC_BASE_URL or "https://api.anthropic.com"
 
     if not api_key and not ANTHROPIC_BASE_URL:
         raise RuntimeError(
-            f"{name}: ANTHROPIC_API_KEY not set and no ANTHROPIC_BASE_URL proxy configured"
+            f"{name}: No API key found (env or ~/.memstack/api_key) and no ANTHROPIC_BASE_URL proxy configured"
         )
 
     url = f"{base_url.rstrip('/')}/v1/messages"
@@ -502,22 +605,45 @@ def _invoke_api_agent(name: str, prompt: str, system_prompt: str,
     usage = data.get("usage", {})
     input_tokens = usage.get("input_tokens", 0)
     output_tokens = usage.get("output_tokens", 0)
+    cache_read_tokens = usage.get("cache_read_input_tokens", 0)
+    cache_creation_tokens = usage.get("cache_creation_input_tokens", 0)
+    total_input_tokens = input_tokens + cache_read_tokens
+
+    resp_model = data.get("model", model or "claude-sonnet-4-6")
+    actual_cost = _calculate_api_cost(
+        resp_model, input_tokens, output_tokens,
+        cache_read_tokens, cache_creation_tokens,
+    )
 
     if log_path:
         ts = time.strftime("%H:%M:%S")
         with open(log_path, "a", encoding="utf-8") as f:
             f.write(f"[{ts}] Response: {len(output)} chars, "
-                    f"in={input_tokens} out={output_tokens}\n")
+                    f"in={total_input_tokens} out={output_tokens}\n")
 
+    stats_name = display_name or name
     try:
         log_agent_invocation(
-            name, len(prompt), len(output), session_id, working_dir,
-            input_tokens=input_tokens, output_tokens=output_tokens, cost_usd=0.0,
+            stats_name, len(prompt), len(output), session_id, working_dir,
+            input_tokens=total_input_tokens, output_tokens=output_tokens, cost_usd=actual_cost,
+        )
+    except Exception:
+        pass
+
+    try:
+        _project = os.path.basename(working_dir) if working_dir else None
+        log_api_cost(
+            session_id=session_id, agent_name=stats_name, model=resp_model,
+            input_tokens=total_input_tokens, output_tokens=output_tokens,
+            actual_cost_usd=actual_cost, execution_mode="api",
+            project=_project,
+            cache_read_tokens=cache_read_tokens,
+            cache_creation_tokens=cache_creation_tokens,
         )
     except Exception:
         pass
 
-    return output, input_tokens, output_tokens
+    return output, total_input_tokens, output_tokens
 
 
 # ---------------------------------------------------------------------------
@@ -528,13 +654,15 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
                    skip_permissions: bool = False,
                    session_id: Optional[str] = None, timeout: int = AGENT_TIMEOUT,
                    model: str = "", disallowed_tools: Optional[list[str]] = None,
-                   session: Optional["Session"] = None) -> tuple[str, int, int, int]:
-    """Run a single claude --print invocation and return the output."""
+                   session: Optional["Session"] = None,
+                   display_name: str = "",
+                   execution_mode: str = "subscription") -> tuple[str, int, int, int]:
+    """Run a single claude interactive streaming invocation and return the output."""
     claude_bin = shutil.which("claude")
     if not claude_bin:
         raise FileNotFoundError("'claude' CLI not found on PATH")
 
-    cmd = [claude_bin, "--print", "--verbose", "--output-format", "stream-json"]
+    cmd = [claude_bin, "--verbose", "--output-format", "stream-json", "--input-format", "stream-json"]
     if skip_permissions:
         cmd.append("--dangerously-skip-permissions")
     if model:
@@ -552,23 +680,19 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
             f.write(f"[{ts}] === Invoking {name} ===\n")
             f.write(f"[{ts}] Prompt length: {len(prompt)} chars\n")
 
-    prompt_dir = log_path.parent if log_path else Path.home() / ".memstack" / "agent-runner"
-    prompt_dir.mkdir(parents=True, exist_ok=True)
-    prompt_file = prompt_dir / f"{name}_prompt.txt"
-    prompt_file.write_text(prompt, encoding="utf-8")
-
-    stdin_fh = open(prompt_file, "r", encoding="utf-8")  # noqa: SIM115
     global _current_process
     proc = subprocess.Popen(
         cmd,
-        stdin=stdin_fh,
+        stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         cwd=working_dir,
-        env=_build_env(),
+        env=_build_env(
+            strip_api_key=(execution_mode == "subscription"),
+            inject_api_key=_load_api_key() if execution_mode == "api" else None,
+        ),
         creationflags=0,
     )
-    stdin_fh.close()
     with _lock:
         _current_process = proc
 
@@ -603,10 +727,24 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
         for raw_line in proc.stderr:
             stderr_chunks.append(raw_line.decode("utf-8", errors="replace"))
 
+    def _write_stdin() -> None:
+        try:
+            msg = json.dumps({"type": "user", "message": {"role": "user", "content": prompt}})
+            proc.stdin.write((msg + "\n").encode("utf-8"))
+            proc.stdin.flush()
+        finally:
+            proc.stdin.close()
+
+    # Start reader threads BEFORE writing stdin to prevent pipe deadlock.
+    # On Windows, anonymous pipes have a ~4KB buffer. Large prompts exceed
+    # this, blocking the write until the subprocess reads. If the subprocess
+    # writes init events to stdout first, nobody drains them — deadlock.
     t_out = threading.Thread(target=_read_stdout, daemon=True)
     t_err = threading.Thread(target=_read_stderr, daemon=True)
+    t_in = threading.Thread(target=_write_stdin, daemon=True)
     t_out.start()
     t_err.start()
+    t_in.start()
 
     watchdog = threading.Timer(timeout, _watchdog_kill)
     watchdog.daemon = True
@@ -629,6 +767,7 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
             if _current_process is proc:
                 _current_process = None
 
+    t_in.join(timeout=10)
     t_out.join(timeout=10)
     t_err.join(timeout=10)
 
@@ -644,7 +783,7 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
 
     raw_stdout = stdout_data or ""
     stderr = stderr_data or ""
-    output, input_tokens, output_tokens, cost_usd, context_tokens = _parse_stream_json(raw_stdout)
+    output, input_tokens, output_tokens, cost_usd, context_tokens, stream_model = _parse_stream_json(raw_stdout)
     output = output.strip()
     ts = time.strftime("%H:%M:%S")
 
@@ -667,14 +806,28 @@ def _invoke_agent(name: str, prompt: str, working_dir: str, log_path: Optional[P
             f"{name} exited with code {proc.returncode}: {stderr[:300]}"
         )
 
+    stats_name = display_name or name
     try:
         log_agent_invocation(
-            name, len(prompt), len(output), session_id, working_dir,
+            stats_name, len(prompt), len(output), session_id, working_dir,
             input_tokens=input_tokens, output_tokens=output_tokens, cost_usd=cost_usd,
         )
     except Exception:
         pass
 
+    try:
+        resolved_model = stream_model or model or "claude-sonnet-4-6"
+        exec_mode = "api" if cost_usd and cost_usd > 0 else "subscription"
+        _project = os.path.basename(working_dir) if working_dir else None
+        log_api_cost(
+            session_id=session_id, agent_name=stats_name, model=resolved_model,
+            input_tokens=input_tokens, output_tokens=output_tokens,
+            actual_cost_usd=cost_usd, execution_mode=exec_mode,
+            project=_project,
+        )
+    except Exception:
+        pass
+
     return output, input_tokens, output_tokens, context_tokens
 
 
@@ -697,6 +850,8 @@ class Session:
         self.auto_commit = auto_commit
         self.blocked_mcp_servers = blocked_mcp_servers or []
         self.auto_committed = False
+        self.total_duration_seconds: int = 0
+        self._start_monotonic: float = 0.0
         self.timeout = max(5, min(120, timeout_minutes)) * 60
         self.status = "running"
         self.result: Optional[str] = None
@@ -723,6 +878,8 @@ class Session:
 
     def _save_state(self) -> None:
         STATE_DIR.mkdir(parents=True, exist_ok=True)
+        if self.status in ("completed", "error", "stopped") and self.total_duration_seconds == 0 and self._start_monotonic > 0:
+            self.total_duration_seconds = round(time.monotonic() - self._start_monotonic)
         data = {
             "session_id": self.session_id,
             "status": self.status,
@@ -735,6 +892,7 @@ class Session:
             "max_iterations": self.max_iterations,
             "result": self.result,
             "auto_committed": self.auto_committed,
+            "total_duration_seconds": self.total_duration_seconds,
         }
         try:
             STATE_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
@@ -786,6 +944,7 @@ class Session:
             "result": self.result,
             "auto_committed": self.auto_committed,
             "commit_summary": commit_summary,
+            "total_duration_seconds": self.total_duration_seconds,
         }
 
 
@@ -804,17 +963,19 @@ _current_process = None
 # ---------------------------------------------------------------------------
 
 def _orchestrate(session: Session) -> None:
-    """Run the Manager → Builder → Reviewer loop using --print invocations."""
+    """Run the Manager → Builder → Reviewer loop."""
+    session._start_monotonic = time.monotonic()
     session_log_dir = STATE_DIR / "sessions" / session.session_id
 
     try:
-        # Load execution modes for this run
+        # Load execution modes and custom display names for this run
         agent_modes = load_agent_modes()
-        has_api_key = bool(os.environ.get("ANTHROPIC_API_KEY") or ANTHROPIC_BASE_URL)
+        display_names = _load_agent_display_names()
+        has_api_key = bool(_load_api_key() or ANTHROPIC_BASE_URL)
         for _ag in ("manager", "builder", "reviewer"):
             if agent_modes[_ag] == "api" and not has_api_key:
                 agent_modes[_ag] = "subscription"
-                print(f"[agent-runner] {_ag}: mode=api but no API key set, falling back to subscription", file=sys.stderr)
+                print(f"[agent-runner] {_ag}: mode=api but no API key found, falling back to subscription", file=sys.stderr)
 
         # Step 1: Manager analyzes the task
         session.agents["manager"]["status"] = "busy"
@@ -839,6 +1000,7 @@ def _orchestrate(session: Session) -> None:
                     model=session.models.get("manager", ""),
                     session_id=session.session_id,
                     working_dir=session.working_dir,
+                    display_name=display_names["manager"],
                 )
                 m_ctx = m_in
             else:
@@ -848,6 +1010,8 @@ def _orchestrate(session: Session) -> None:
                     skip_permissions=True, session_id=session.session_id,
                     timeout=min(600, session.timeout),
                     model=session.models.get("manager", ""),
+                    display_name=display_names["manager"],
+                    execution_mode=agent_modes["manager"],
                 )
         except subprocess.TimeoutExpired:
             session.agents["manager"]["status"] = "timeout"
@@ -912,6 +1076,8 @@ def _orchestrate(session: Session) -> None:
                         model=session.models.get("builder", ""),
                         disallowed_tools=session.blocked_mcp_servers,
                         session=session,
+                        display_name=display_names["builder"],
+                        execution_mode=agent_modes["builder"],
                     )
                 else:
                     builder_output, b_in, b_out = _invoke_api_agent(
@@ -922,6 +1088,7 @@ def _orchestrate(session: Session) -> None:
                         model=session.models.get("builder", ""),
                         session_id=session.session_id,
                         working_dir=session.working_dir,
+                        display_name=display_names["builder"],
                     )
                     b_ctx = b_in
             except subprocess.TimeoutExpired:
@@ -990,6 +1157,7 @@ def _orchestrate(session: Session) -> None:
                         model=session.models.get("reviewer", ""),
                         session_id=session.session_id,
                         working_dir=session.working_dir,
+                        display_name=display_names["reviewer"],
                     )
                     r_ctx = r_in
                 else:
@@ -999,6 +1167,8 @@ def _orchestrate(session: Session) -> None:
                         skip_permissions=True, session_id=session.session_id,
                         timeout=session.timeout,
                         model=session.models.get("reviewer", ""),
+                        display_name=display_names["reviewer"],
+                        execution_mode=agent_modes["reviewer"],
                     )
             except subprocess.TimeoutExpired:
                 session.agents["reviewer"]["status"] = "timeout"