aiwcli 0.9.7 → 0.10.0

package/dist/templates/cc-native/_cc-native/lib/orchestrator.py

@@ -15,9 +15,14 @@ from typing import Any, Dict, List, Optional
 _lib_dir = Path(__file__).resolve().parent
 sys.path.insert(0, str(_lib_dir))
 
-from utils import OrchestratorResult, eprint, parse_json_maybe
+from utils import OrchestratorResult, parse_json_maybe
 from reviewers.base import AgentConfig, OrchestratorConfig
 
+# Import logger
+_shared_logger = Path(__file__).resolve().parent.parent.parent / "_shared" / "lib"
+sys.path.insert(0, str(_shared_logger))
+from base.logger import log_debug, log_info, log_warn, log_error
+
 # Import shared subprocess utilities
 _shared_lib = Path(__file__).resolve().parent.parent.parent / "_shared" / "lib" / "base"
 sys.path.insert(0, str(_shared_lib))
@@ -59,6 +64,44 @@ ORCHESTRATOR_SCHEMA: Dict[str, Any] = {
 }
 
 
+def build_orchestrator_schema(
+    valid_agent_names: List[str],
+    categories: List[str],
+) -> Dict[str, Any]:
+    """Build orchestrator JSON schema with enum-constrained agent names.
+
+    When valid_agent_names is non-empty, selectedAgents items are constrained
+    to only those names via JSON schema enum. This prevents the LLM from
+    hallucinating or misspelling agent names.
+
+    Args:
+        valid_agent_names: List of valid agent names for enum constraint.
+        categories: List of valid complexity categories.
+
+    Returns:
+        JSON schema dict for orchestrator structured output.
+    """
+    items_schema: Dict[str, Any] = {"type": "string"}
+    if valid_agent_names:
+        items_schema["enum"] = valid_agent_names
+
+    return {
+        "type": "object",
+        "properties": {
+            "complexity": {"type": "string", "enum": ["simple", "medium", "high"]},
+            "category": {"type": "string", "enum": categories},
+            "selectedAgents": {
+                "type": "array",
+                "items": items_schema,
+            },
+            "reasoning": {"type": "string"},
+            "skipReason": {"type": "string"},
+        },
+        "required": ["complexity", "category", "selectedAgents", "reasoning"],
+        "additionalProperties": False,
+    }
+
+
 # ---------------------------
 # Output Parsing
 # ---------------------------
@@ -81,18 +124,18 @@ def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
         result = json.loads(raw)
         if isinstance(result, dict):
             if "structured_output" in result:
-                eprint("[orchestrator:parse] Found structured_output in root dict")
+                log_debug("orchestrator", "Found structured_output in root dict", component="parse")
                 return result["structured_output"]
             if result.get("type") == "assistant":
                 message = result.get("message", {})
                 content = message.get("content", [])
                 for item in content:
                     if isinstance(item, dict) and item.get("name") == "StructuredOutput":
-                        eprint("[orchestrator:parse] Found StructuredOutput in assistant message content")
+                        log_debug("orchestrator", "Found StructuredOutput in assistant message content", component="parse")
                         return item.get("input", {})
-                eprint("[orchestrator:parse] Assistant message found but no StructuredOutput tool use in content")
+                log_debug("orchestrator", "Assistant message found but no StructuredOutput tool use in content", component="parse")
         elif isinstance(result, list):
-            eprint(f"[orchestrator:parse] Received list of {len(result)} events, searching for assistant message")
+            log_debug("orchestrator", f"Received list of {len(result)} events, searching for assistant message", component="parse")
             for i, event in enumerate(result):
                 if not isinstance(event, dict):
                     continue
@@ -101,16 +144,16 @@ def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
                     content = message.get("content", [])
                     for item in content:
                         if isinstance(item, dict) and item.get("name") == "StructuredOutput":
-                            eprint(f"[orchestrator:parse] Found StructuredOutput in event[{i}] assistant message")
+                            log_debug("orchestrator", f"Found StructuredOutput in event[{i}] assistant message", component="parse")
                             return item.get("input", {})
-            eprint("[orchestrator:parse] No StructuredOutput found in any assistant message in event list")
+            log_debug("orchestrator", "No StructuredOutput found in any assistant message in event list", component="parse")
     except json.JSONDecodeError as e:
-        eprint(f"[orchestrator:parse] JSON decode error: {e}")
+        log_warn("orchestrator", f"JSON decode error: {e}", component="parse")
     except Exception as e:
-        eprint(f"[orchestrator:parse] Unexpected error during structured parsing: {e}")
+        log_error("orchestrator", f"Unexpected error during structured parsing: {e}", component="parse")
 
     # Fallback to heuristic extraction
-    eprint("[orchestrator:parse] No structured output found, falling back to heuristic JSON extraction")
+    log_debug("orchestrator", "No structured output found, falling back to heuristic JSON extraction", component="parse")
     return parse_json_maybe(raw)
 
 
@@ -123,6 +166,7 @@ def run_orchestrator(
     agent_library: List[AgentConfig],
     config: OrchestratorConfig,
     settings: Dict[str, Any],
+    mandatory_names: Optional[set] = None,
 ) -> OrchestratorResult:
     """Run the orchestrator agent to analyze plan complexity and select reviewers.
 
@@ -131,40 +175,54 @@ def run_orchestrator(
         agent_library: List of available agents
         config: Orchestrator configuration (model, timeout)
         settings: Agent review settings (agentSelection, complexityCategories)
+        mandatory_names: Set of agent names that always run (excluded from selection)
 
     Returns:
         OrchestratorResult with complexity, category, and selected agents
     """
-    eprint("[orchestrator] Starting plan analysis...")
+    log_info("orchestrator", "Starting plan analysis...")
+
+    if mandatory_names is None:
+        mandatory_names = set()
 
     selection = settings.get("agentSelection", DEFAULT_AGENT_SELECTION)
     categories = settings.get("complexityCategories", DEFAULT_COMPLEXITY_CATEGORIES)
     fallback_count = selection.get("fallbackCount", 2)
 
+    # Filter out mandatory agents — they always run, no need for orchestrator to select them
+    non_mandatory = [a for a in agent_library if a.enabled and a.name not in mandatory_names]
+    valid_names = [a.name for a in non_mandatory]
+
+    log_debug("orchestrator", f"Mandatory agents (always run): {sorted(mandatory_names)}")
+    log_debug("orchestrator", f"Non-mandatory agents for selection: {valid_names}")
+
     claude_path = shutil.which("claude")
     if claude_path is None:
-        eprint("[orchestrator] Claude CLI not found on PATH, falling back to medium complexity")
+        log_warn("orchestrator", "Claude CLI not found on PATH, falling back to medium complexity")
         return OrchestratorResult(
             complexity="medium",
             category="code",
-            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            selected_agents=[a.name for a in non_mandatory][:fallback_count],
             reasoning="Orchestrator skipped - Claude CLI not found",
             error="claude CLI not found on PATH",
         )
 
-    eprint(f"[orchestrator] Found Claude CLI at: {claude_path}")
+    log_debug("orchestrator", f"Found Claude CLI at: {claude_path}")
 
-    # Build agent list for prompt with rich descriptions
+    # Build agent list from non-mandatory agents only
     agent_list = "\n".join([
         f"- {a.name} [{', '.join(a.categories)}]\n"
         f"  Focus: {a.focus}\n"
         f"  Expertise: {a.description}"
-        for a in agent_library if a.enabled
+        for a in non_mandatory
     ])
     category_list = "/".join(categories)
-    simple_range = f"{selection.get('simple', {}).get('min', 0)}-{selection.get('simple', {}).get('max', 0)}"
-    medium_range = f"{selection.get('medium', {}).get('min', 1)}-{selection.get('medium', {}).get('max', 2)}"
-    high_range = f"{selection.get('high', {}).get('min', 2)}-{selection.get('high', {}).get('max', 4)}"
+
+    # Compute additional agent counts (total minus mandatory count)
+    mandatory_count = len([a for a in agent_library if a.name in mandatory_names])
+    simple_additional = max(0, selection.get("simple", {}).get("max", 3) - mandatory_count)
+    medium_additional = max(0, selection.get("medium", {}).get("max", 8) - mandatory_count)
+    high_additional = max(0, selection.get("high", {}).get("max", 12) - mandatory_count)
 
     # System prompt with orchestrator instructions
     system_prompt = """You are a plan orchestrator for code review. Your job is to analyze plans and select appropriate reviewer agents.
@@ -180,15 +238,16 @@ When selecting agents:
     # User prompt with plan and agent list
     prompt = f"""Analyze this plan and select appropriate reviewer agents.
 
-Available agents:
+Available agents (select ONLY from this list):
 {agent_list}
 
-Selection rules:
-- simple complexity = {simple_range} agents
-- medium complexity = {medium_range} agents
-- high complexity = {high_range} agents
+Selection rules (number of ADDITIONAL agents to select from the list above):
+- simple complexity = {simple_additional} agents
+- medium complexity = {medium_additional} agents
+- high complexity = {high_additional} agents
 - Only select agents whose categories match the plan category ({category_list})
 - Non-technical plans (life, business) typically need 0 code-focused agents
+- Note: mandatory agents run separately and are NOT listed above
 
 PLAN:
 <<<
@@ -197,7 +256,9 @@ PLAN:
 
 Call StructuredOutput now with: complexity, category, selectedAgents, reasoning"""
 
-    schema_json = json.dumps(ORCHESTRATOR_SCHEMA, ensure_ascii=False)
+    # Use dynamic schema with enum constraint when we have valid agent names
+    schema = build_orchestrator_schema(valid_names, categories) if valid_names else ORCHESTRATOR_SCHEMA
+    schema_json = json.dumps(schema, ensure_ascii=False)
 
     cmd_args = [
         claude_path,
@@ -210,7 +271,7 @@ Call StructuredOutput now with: complexity, category, selectedAgents, reasoning"
         "--system-prompt", system_prompt,
     ]
 
-    eprint(f"[orchestrator] Running with model: {config.model}, timeout: {config.timeout}s")
+    log_info("orchestrator", f"Running with model: {config.model}, timeout: {config.timeout}s")
 
     # Get environment for internal subprocess (bypasses hooks)
     env = get_internal_subprocess_env()
@@ -227,48 +288,48 @@ Call StructuredOutput now with: complexity, category, selectedAgents, reasoning"
             env=env,
         )
     except subprocess.TimeoutExpired:
-        eprint(f"[orchestrator] TIMEOUT after {config.timeout}s, falling back to medium complexity")
+        log_warn("orchestrator", f"TIMEOUT after {config.timeout}s, falling back to medium complexity")
         return OrchestratorResult(
             complexity="medium",
             category="code",
-            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            selected_agents=[a.name for a in non_mandatory][:fallback_count],
             reasoning="Orchestrator timed out - defaulting to medium complexity",
             error=f"Orchestrator timed out after {config.timeout}s",
         )
     except Exception as ex:
-        eprint(f"[orchestrator] EXCEPTION: {ex}, falling back to medium complexity")
+        log_error("orchestrator", f"Exception: {ex}, falling back to medium complexity")
         return OrchestratorResult(
             complexity="medium",
             category="code",
-            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            selected_agents=[a.name for a in non_mandatory][:fallback_count],
             reasoning=f"Orchestrator failed: {ex}",
             error=str(ex),
         )
 
-    eprint(f"[orchestrator] Exit code: {p.returncode}")
+    log_debug("orchestrator", f"Exit code: {p.returncode}")
 
     raw = (p.stdout or "").strip()
     if p.stderr:
-        eprint(f"[orchestrator] stderr: {p.stderr[:300]}")
+        log_debug("orchestrator", f"stderr: {p.stderr[:300]}")
 
     obj = _parse_claude_output(raw)
 
     # Debug logging to diagnose empty selectedAgents issue
-    eprint(f"[orchestrator:debug] Raw output length: {len(raw)} chars")
+    log_debug("orchestrator", f"Raw output length: {len(raw)} chars")
     if raw:
-        eprint(f"[orchestrator:debug] Raw output (first 500 chars): {raw[:500]}")
-    eprint(f"[orchestrator:debug] Parsed obj: {obj}")
+        log_debug("orchestrator", f"Raw output (first 500 chars): {raw[:500]}")
+    log_debug("orchestrator", f"Parsed obj: {obj}")
     if obj:
-        eprint(f"[orchestrator:debug] obj keys: {list(obj.keys())}")
-        eprint(f"[orchestrator:debug] selectedAgents value: {obj.get('selectedAgents', 'MISSING')}")
-        eprint(f"[orchestrator:debug] reasoning value: {obj.get('reasoning', 'MISSING')}")
+        log_debug("orchestrator", f"obj keys: {list(obj.keys())}")
+        log_debug("orchestrator", f"selectedAgents value: {obj.get('selectedAgents', 'MISSING')}")
+        log_debug("orchestrator", f"reasoning value: {obj.get('reasoning', 'MISSING')}")
 
     if not obj:
-        eprint("[orchestrator] Failed to parse output, falling back to medium complexity")
+        log_warn("orchestrator", "Failed to parse output, falling back to medium complexity")
         return OrchestratorResult(
             complexity="medium",
             category="code",
-            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            selected_agents=[a.name for a in non_mandatory][:fallback_count],
             reasoning="Orchestrator output could not be parsed",
             error="Failed to parse orchestrator output",
         )
@@ -289,8 +350,8 @@ Call StructuredOutput now with: complexity, category, selectedAgents, reasoning"
     reasoning = str(obj.get("reasoning", "")).strip() or "No reasoning provided"
     skip_reason = obj.get("skipReason")
 
-    eprint(f"[orchestrator] Result: complexity={complexity}, category={category}, agents={selected_agents}")
-    eprint(f"[orchestrator] Reasoning: {reasoning}")
+    log_info("orchestrator", f"Result: complexity={complexity}, category={category}, agents={selected_agents}")
+    log_debug("orchestrator", f"Reasoning: {reasoning}")
 
     return OrchestratorResult(
         complexity=complexity,

package/dist/templates/cc-native/_cc-native/lib/reviewers/agent.py

@@ -15,10 +15,15 @@ from typing import Any, Dict, Optional
 _lib_dir = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(_lib_dir))
 
-from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from utils import ReviewerResult, parse_json_maybe, coerce_to_review
 from debug import debug_log, debug_raw
 from .base import AgentConfig, AGENT_REVIEW_PROMPT_PREFIX
 
+# Import logger
+_shared_logger = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib"
+sys.path.insert(0, str(_shared_logger))
+from base.logger import log_debug, log_info, log_warn, log_error
+
 # Import shared subprocess utilities
 _shared_lib = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib" / "base"
 sys.path.insert(0, str(_shared_lib))
@@ -43,18 +48,18 @@ def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
         result = json.loads(raw)
         if isinstance(result, dict):
             if "structured_output" in result:
-                eprint("[parse] Found structured_output in root dict")
+                log_debug("agent", "Found structured_output in root dict", component="parse")
                 return result["structured_output"]
             if result.get("type") == "assistant":
                 message = result.get("message", {})
                 content = message.get("content", [])
                 for item in content:
                     if isinstance(item, dict) and item.get("name") == "StructuredOutput":
-                        eprint("[parse] Found StructuredOutput in assistant message content")
+                        log_debug("agent", "Found StructuredOutput in assistant message content", component="parse")
                         return item.get("input", {})
-                eprint("[parse] Assistant message found but no StructuredOutput tool use in content")
+                log_debug("agent", "Assistant message found but no StructuredOutput tool use in content", component="parse")
         elif isinstance(result, list):
-            eprint(f"[parse] Received list of {len(result)} events, searching for assistant message")
+            log_debug("agent", f"Received list of {len(result)} events, searching for assistant message", component="parse")
             for i, event in enumerate(result):
                 if not isinstance(event, dict):
                     continue
@@ -63,16 +68,16 @@ def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
                     content = message.get("content", [])
                     for item in content:
                         if isinstance(item, dict) and item.get("name") == "StructuredOutput":
-                            eprint(f"[parse] Found StructuredOutput in event[{i}] assistant message")
+                            log_debug("agent", f"Found StructuredOutput in event[{i}] assistant message", component="parse")
                             return item.get("input", {})
-            eprint("[parse] No StructuredOutput found in any assistant message in event list")
+            log_debug("agent", "No StructuredOutput found in any assistant message in event list", component="parse")
     except json.JSONDecodeError as e:
-        eprint(f"[parse] JSON decode error: {e}")
+        log_warn("agent", f"JSON decode error: {e}", component="parse")
     except Exception as e:
-        eprint(f"[parse] Unexpected error during structured parsing: {e}")
+        log_error("agent", f"Unexpected error during structured parsing: {e}", component="parse")
 
     # Fallback to heuristic extraction with required field validation
-    eprint("[parse] No structured output found, falling back to heuristic JSON extraction")
+    log_debug("agent", "No structured output found, falling back to heuristic JSON extraction", component="parse")
     return parse_json_maybe(raw, require_fields=["verdict", "summary"])
 
 
@@ -99,7 +104,7 @@ def run_agent_review(
     """
     claude_path = shutil.which("claude")
     if claude_path is None:
-        eprint(f"[{agent.name}] Claude CLI not found on PATH")
+        log_warn(agent.name, "Claude CLI not found on PATH")
         return ReviewerResult(
             name=agent.name,
             ok=False,
@@ -109,7 +114,7 @@ def run_agent_review(
             err="claude CLI not found on PATH",
         )
 
-    eprint(f"[{agent.name}] Found Claude CLI at: {claude_path}")
+    log_debug(agent.name, f"Found Claude CLI at: {claude_path}")
 
     # User prompt - direct instruction to call StructuredOutput immediately
     prompt = f"""IMMEDIATELY call StructuredOutput with your review of the plan below.
@@ -139,7 +144,7 @@ PLAN:
         full_prompt = AGENT_REVIEW_PROMPT_PREFIX + "\n\n---\n\n" + agent.system_prompt
         cmd_args.extend(["--system-prompt", full_prompt])
 
-    eprint(f"[{agent.name}] Running with model: {agent.model}, timeout: {timeout}s")
+    log_info(agent.name, f"Running with model: {agent.model}, timeout: {timeout}s")
 
     # Get environment for internal subprocess (bypasses hooks)
     env = get_internal_subprocess_env()
@@ -156,16 +161,16 @@ PLAN:
             env=env,
         )
     except subprocess.TimeoutExpired:
-        eprint(f"[{agent.name}] TIMEOUT after {timeout}s")
+        log_warn(agent.name, f"TIMEOUT after {timeout}s")
         return ReviewerResult(agent.name, False, "error", {}, "", f"{agent.name} timed out after {timeout}s")
     except Exception as ex:
-        eprint(f"[{agent.name}] EXCEPTION: {ex}")
+        log_error(agent.name, f"Exception: {ex}")
         return ReviewerResult(agent.name, False, "error", {}, "", f"{agent.name} failed to run: {ex}")
 
-    eprint(f"[{agent.name}] Exit code: {p.returncode}")
-    eprint(f"[{agent.name}] stdout length: {len(p.stdout or '')} chars")
+    log_debug(agent.name, f"Exit code: {p.returncode}")
+    log_debug(agent.name, f"stdout length: {len(p.stdout or '')} chars")
     if p.stderr:
-        eprint(f"[{agent.name}] stderr: {p.stderr[:500]}")
+        log_debug(agent.name, f"stderr: {p.stderr[:500]}")
 
     raw = (p.stdout or "").strip()
     err = (p.stderr or "").strip()
@@ -184,7 +189,7 @@ PLAN:
         })
 
     if raw:
-        eprint(f"[{agent.name}] stdout preview: {raw[:500]}")
+        log_debug(agent.name, f"stdout preview: {raw[:500]}")
 
     obj = _parse_claude_output(raw)
 
@@ -201,9 +206,9 @@ PLAN:
         })
 
     if obj:
-        eprint(f"[{agent.name}] Parsed JSON successfully, verdict: {obj.get('verdict', 'N/A')}")
+        log_info(agent.name, f"Parsed JSON successfully, verdict: {obj.get('verdict', 'N/A')}")
     else:
-        eprint(f"[{agent.name}] Failed to parse JSON from output")
+        log_warn(agent.name, "Failed to parse JSON from output")
 
     ok, verdict, norm = coerce_to_review(obj, "Retry or check agent configuration.")
 

package/dist/templates/cc-native/_cc-native/lib/reviewers/codex.py

@@ -16,9 +16,14 @@ from typing import Any, Dict
 _lib_dir = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(_lib_dir))
 
-from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from utils import ReviewerResult, parse_json_maybe, coerce_to_review
 from .base import REVIEW_PROMPT_PREFIX
 
+# Import logger
+_shared_logger = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib"
+sys.path.insert(0, str(_shared_logger))
+from base.logger import log_debug, log_info, log_warn, log_error
+
 
 def run_codex_review(
     plan: str,
@@ -41,7 +46,7 @@ def run_codex_review(
 
     codex_path = shutil.which("codex")
     if codex_path is None:
-        eprint("[codex] CLI not found on PATH")
+        log_warn("codex", "CLI not found on PATH")
         return ReviewerResult(
             name="codex",
             ok=False,
@@ -51,7 +56,7 @@ def run_codex_review(
             err="codex CLI not found on PATH",
         )
 
-    eprint(f"[codex] Found CLI at: {codex_path}")
+    log_debug("codex", f"Found CLI at: {codex_path}")
 
     prompt = f"""{REVIEW_PROMPT_PREFIX}
 Return ONLY a JSON object that matches this JSON Schema:
@@ -87,7 +92,7 @@ PLAN:
             cmd.insert(2, "--model")
             cmd.insert(3, model)
 
-        eprint(f"[codex] Running command: {' '.join(cmd)}")
+        log_debug("codex", f"Running command: {' '.join(cmd)}")
 
         try:
             p = subprocess.run(
@@ -100,13 +105,13 @@ PLAN:
                 errors='replace',
             )
         except subprocess.TimeoutExpired:
-            eprint(f"[codex] TIMEOUT after {timeout}s")
+            log_warn("codex", f"TIMEOUT after {timeout}s")
             return ReviewerResult("codex", False, "error", {}, "", f"codex timed out after {timeout}s")
         except Exception as ex:
-            eprint(f"[codex] EXCEPTION: {ex}")
+            log_error("codex", f"Exception: {ex}")
             return ReviewerResult("codex", False, "error", {}, "", f"codex failed to run: {ex}")
 
-        eprint(f"[codex] Exit code: {p.returncode}")
+        log_debug("codex", f"Exit code: {p.returncode}")
 
         raw = ""
         if out_path.exists():

package/dist/templates/cc-native/_cc-native/lib/reviewers/gemini.py

@@ -15,7 +15,12 @@ from typing import Any, Dict
 _lib_dir = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(_lib_dir))
 
-from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from utils import ReviewerResult, parse_json_maybe, coerce_to_review
+
+# Import logger
+_shared_logger = Path(__file__).resolve().parent.parent.parent.parent / "_shared" / "lib"
+sys.path.insert(0, str(_shared_logger))
+from base.logger import log_debug, log_info, log_warn, log_error
 
 
 def run_gemini_review(
@@ -39,7 +44,7 @@ def run_gemini_review(
 
     gemini_path = shutil.which("gemini")
     if gemini_path is None:
-        eprint("[gemini] CLI not found on PATH")
+        log_warn("gemini", "CLI not found on PATH")
         return ReviewerResult(
             name="gemini",
             ok=False,
@@ -49,7 +54,7 @@ def run_gemini_review(
             err="gemini CLI not found on PATH",
         )
 
-    eprint(f"[gemini] Found CLI at: {gemini_path}")
+    log_debug("gemini", f"Found CLI at: {gemini_path}")
 
     instruction = f"""
 
@@ -73,7 +78,7 @@ Return ONLY a JSON object that matches this JSON Schema (no markdown, no code fe
     if model:
         cmd.extend(["--model", model])
 
-    eprint("[gemini] Running command: gemini -y -p <instruction>")
+    log_debug("gemini", "Running command: gemini -y -p <instruction>")
 
     try:
         p = subprocess.run(
@@ -86,13 +91,13 @@ Return ONLY a JSON object that matches this JSON Schema (no markdown, no code fe
             errors='replace',
         )
     except subprocess.TimeoutExpired:
-        eprint(f"[gemini] TIMEOUT after {timeout}s")
+        log_warn("gemini", f"TIMEOUT after {timeout}s")
         return ReviewerResult("gemini", False, "error", {}, "", f"gemini timed out after {timeout}s")
     except Exception as ex:
-        eprint(f"[gemini] EXCEPTION: {ex}")
+        log_error("gemini", f"Exception: {ex}")
         return ReviewerResult("gemini", False, "error", {}, "", f"gemini failed to run: {ex}")
 
-    eprint(f"[gemini] Exit code: {p.returncode}")
+    log_debug("gemini", f"Exit code: {p.returncode}")
 
     raw = (p.stdout or "").strip()
     err = (p.stderr or "").strip()