nonoka-cli 0.2.5__tar.gz → 0.2.6__tar.gz

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/.gitignore

@@ -61,4 +61,7 @@ verdaccio-storage/
 
 # Private planning documents
 DESIGN.md
-REFACTOR.md
+REFACTOR.md
+# Runtime nonoka project artifacts
+.nonoka/repo_map.jsonl
+.nonoka/tasks/

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonoka-cli
-Version: 0.2.5
+Version: 0.2.6
 Summary: OpenCode backend for the Nonoka Agent framework
 License: MIT
 License-File: LICENSE

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nonoka-cli"
-version = "0.2.5"
+version = "0.2.6"
 description = "OpenCode backend for the Nonoka Agent framework"
 readme = "README.md"
 license = { text = "MIT" }

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/src/nonoka_cli/bridge/server.py

@@ -138,9 +138,7 @@ async def _async_main(
 ) -> int:
   """Set up async stdin/stdout and run the bridge server."""
   loop = asyncio.get_event_loop()
-  # Large prompts (repo map, file contents) can produce single NDJSON lines
-  # well above the default 64 KiB StreamReader limit. Bump it to 10 MiB.
-  stdin = asyncio.StreamReader(limit=10 * 1024 * 1024)
+  stdin = asyncio.StreamReader()
   await loop.connect_read_pipe(lambda: asyncio.StreamReaderProtocol(stdin), sys.stdin)
 
   w_transport, w_protocol = await loop.connect_write_pipe(

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/src/nonoka_cli/commands/opencode_cmd.py

@@ -54,8 +54,9 @@ def _build_opencode_permission(config: CLIConfig) -> dict[str, str]:
     permission[tool] = action
 
   # nonoka.yaml permissions take precedence over auto_approve defaults.
-  if config.permissions:
-    permission.update(config.permissions)
+  user_permissions = getattr(config, "permissions", None)
+  if user_permissions:
+    permission.update(user_permissions)
   return permission
 
 

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/src/nonoka_cli/config/models.py

@@ -111,20 +111,16 @@ class RepoMapConfig(BaseModel):
 
 
 class AgentRoleConfig(BaseModel):
-  """Configuration for a single agent role (planner / reviewer)."""
+  """Configuration for a single agent role (planner / executor)."""
   model: str = ""
   max_turns: int = 5
   system_prompt: str = ""
 
 
 class AgentsConfig(BaseModel):
-  """Multi-agent role configuration.
-
-  The ``executor`` role has been removed: the main agent is the executor, and
-  its ``max_turns`` is configured at the top level of ``CLIConfig``.
-  """
+  """Multi-agent role configuration."""
   planner: AgentRoleConfig = Field(default_factory=AgentRoleConfig)
-  reviewer: AgentRoleConfig = Field(default_factory=AgentRoleConfig)
+  executor: AgentRoleConfig = Field(default_factory=AgentRoleConfig)
 
 
 class PluginConfig(BaseModel):
@@ -146,11 +142,9 @@ class CLIConfig(BaseModel):
   Matches the expected structure of ~/.config/nonoka/config.yaml.
   """
   model: str = "gpt-4o"
-  max_turns: int = 20
   system_prompt: str = ""
   api_key: str = ""
   base_url: str = ""
-  permissions: dict[str, str] = Field(default_factory=dict)
   mcp_servers: dict[str, MCPServerConfigModel] = Field(default_factory=dict)
   tool_paths: list[Path] = Field(default_factory=list)
   skills: list[str] = Field(default_factory=list)

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/src/nonoka_cli/core/agent_factory.py

@@ -26,6 +26,7 @@ from nonoka_cli.config.models import CLIConfig
 from nonoka_cli.core.namespaces import (
   PrefixedCapability,
   mcp_tool_name,
+  sanitize_tool_name,
   skill_tool_name,
 )
 from nonoka_cli.core.prompt_builder import SystemPromptBuilder
@@ -143,8 +144,11 @@ class AgentFactory:
     return self._skill_registry
 
   def _executor_max_turns(self) -> int:
-    """Return the configured main-agent max turns."""
-    return self._config.max_turns
+    """Return the configured executor max turns, falling back to 20."""
+    configured = getattr(
+      self._config.agents.executor, "max_turns", None
+    )
+    return configured if configured else 20
 
   def build(
     self,
@@ -153,7 +157,6 @@ class AgentFactory:
     git_summary: str | None = None,
     plugin_summary: str | None = None,
     execution_plan: str | None = None,
-    extra_tools: list[Capability] | None = None,
   ) -> Agent:
     """Build (or rebuild) an Agent from the current configuration.
 
@@ -164,9 +167,6 @@ class AgentFactory:
       repo_map: Optional repo-map block to inject into the system prompt.
       git_summary: Optional git-checkpoint status summary.
       plugin_summary: Optional loaded plugin manifest summary.
-      execution_plan: Optional structured plan produced by the planner agent.
-      extra_tools: Optional additional tools (e.g. sub-agent AgentTools) to
-        register with the Agent.
 
     Returns:
       A nonoka Agent instance.
@@ -233,12 +233,6 @@ class AgentFactory:
           builder = builder.tool(capability)
         logger.debug("agent_factory_mcp_tools", count=len(mcp_tools))
 
-    # Extra tools (e.g. planner/reviewer sub-agents) injected by Orchestrator.
-    if extra_tools:
-      for tool in extra_tools:
-        builder = builder.tool(tool)
-      logger.debug("agent_factory_extra_tools", count=len(extra_tools))
-
     self._agent = builder.build()
     return self._agent
 
@@ -274,7 +268,6 @@ class AgentFactory:
     git_summary: str | None = None,
     plugin_summary: str | None = None,
     execution_plan: str | None = None,
-    extra_tools: list[Capability] | None = None,
   ) -> Agent:
     """Build an Agent for host-managed (e.g. OpenCode) mode.
 
@@ -296,9 +289,6 @@ class AgentFactory:
         in nonoka.yaml.
       external_mcp_servers: Optional host-managed MCP server definitions.
       external_skills: Optional host-managed skill definitions.
-      execution_plan: Optional structured plan produced by the planner agent.
-      extra_tools: Optional additional tools (e.g. sub-agent AgentTools) to
-        register with the Agent.
     """
     if not self._config.model:
       raise AgentBuildError("No model configured. Set 'model' in config.yaml.")
@@ -454,12 +444,6 @@ class AgentFactory:
     for server, cap in mcp_tools:
       builder = builder.tool(PrefixedCapability(cap, f"mcp__{server}__"))
 
-    # Extra tools (e.g. planner/reviewer sub-agents) injected by Orchestrator.
-    if extra_tools:
-      for tool in extra_tools:
-        builder = builder.tool(tool)
-      logger.debug("agent_factory_extra_tools", count=len(extra_tools))
-
     return builder.build()
 
   def _skill_registry_for_build(

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/src/nonoka_cli/core/orchestrator.py

@@ -26,7 +26,6 @@ from nonoka_cli.core.context_trimmer import TurnBasedContextTrimmer
 from nonoka_cli.core.git_service import GitService, build_git_service
 from nonoka_cli.core.mcp_service import MCPService
 from nonoka_cli.core.planning_service import PlanningService, build_planning_service
-from nonoka_cli.core.review_service import ReviewService, build_review_service
 from nonoka_cli.core.plugin_manifest import (
   PluginManifestLoader,
   format_manifest_summary,
@@ -99,7 +98,6 @@ class Orchestrator:
     self._git_service: GitService | None = None
     self._repo_map_service: RepoMapService | None = None
     self._planning_service: PlanningService | None = None
-    self._review_service: ReviewService | None = None
     self._plugin_manifests: list[Any] = []
     self._initialized = False
 
@@ -162,10 +160,6 @@ class Orchestrator:
       working_dir=Path.cwd(),
       config=self._config,
     )
-    self._review_service = build_review_service(
-      working_dir=Path.cwd(),
-      config=self._config,
-    )
 
     # Load project plugin manifests before building the Agent so that
     # allowed_tools / plugin summary can be taken into account.
@@ -191,7 +185,6 @@ class Orchestrator:
       repo_map=repo_map_block,
       git_summary=git_summary,
       plugin_summary=plugin_summary,
-      extra_tools=self._subagent_tools(),
     )
     self._tool_service = ToolService(self._agent_factory, self._tool_loader)
     self._mcp_service = MCPService(self._mcp_manager, self._agent_factory)
@@ -354,19 +347,6 @@ class Orchestrator:
     merged = merge_manifests(self._plugin_manifests)
     return merged.allowed_tools
 
-  def _subagent_tools(self) -> list[Any]:
-    """Return enabled sub-agent AgentTools for injection into the executor.
-
-    Only planner/reviewer tools whose model is configured are returned, so the
-    default executor tool list stays small.
-    """
-    tools: list[Any] = []
-    if self._planning_service is not None and self._planning_service.enabled:
-      tools.append(self._planning_service.agent_tool)
-    if self._review_service is not None and self._review_service.enabled:
-      tools.append(self._review_service.agent_tool)
-    return tools
-
   def _on_config_changed(self, config: CLIConfig) -> None:
     """ConfigManager hot-reload listener: update local reference only."""
     self._config = config
@@ -450,10 +430,7 @@ class Orchestrator:
         logger.info("execute_plan_result", plan_preview=plan[:200] if plan else None)
         if plan and not plan.startswith(("Error", "Planning is disabled")):
           logger.info("execution_plan_generated", plan_length=len(plan))
-          agent = self._agent_factory.build(
-            execution_plan=plan,
-            extra_tools=self._subagent_tools(),
-          )
+          agent = self._agent_factory.build(execution_plan=plan)
       except Exception as exc:
         logger.warning("execution_plan_generation_failed", error=str(exc))
 
@@ -560,7 +537,6 @@ class Orchestrator:
       git_summary=git_summary,
       plugin_summary=plugin_summary,
       execution_plan=execution_plan,
-      extra_tools=self._subagent_tools(),
     )
 
     logger.info(
@@ -618,7 +594,6 @@ class Orchestrator:
       repo_map=repo_map_block,
       git_summary=git_summary,
       plugin_summary=plugin_summary,
-      extra_tools=self._subagent_tools(),
     )
 
     logger.info(

nonoka_cli-0.2.6/src/nonoka_cli/core/planning_service.py

@@ -0,0 +1,89 @@
+"""Planning service for nonoka-cli.
+
+Wires planner/executor configuration (``agents.planner``) to the orchestrator.
+The actual planner implementation has been removed from nonoka-agent in 1.3.4;
+nonoka-cli will provide its own LLM-based planner here in a future release.
+For now the service reports itself as disabled when invoked so the orchestrator
+falls back to single-agent execution.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from nonoka_cli.config.models import AgentsConfig, CLIConfig
+
+
+class PlanningService:
+  """Adapts the nonoka-agent planner tool to CLI config."""
+
+  def __init__(
+    self,
+    working_dir: Path,
+    config: AgentsConfig | None = None,
+    default_model: str | None = None,
+  ):
+    self._working_dir = working_dir
+    self._config = config or AgentsConfig()
+    self._default_model = default_model
+
+  @property
+  def enabled(self) -> bool:
+    return bool(self.planner_model)
+
+  @property
+  def planner_model(self) -> str:
+    """Return the effective planner model identifier."""
+    configured = self._config.planner.model
+    if configured:
+      return configured
+    if self._default_model:
+      return self._default_model
+    return ""
+
+  @property
+  def executor_model(self) -> str:
+    """Return the effective executor model identifier."""
+    configured = self._config.executor.model
+    if configured:
+      return configured
+    if self._default_model:
+      return self._default_model
+    return ""
+
+  @property
+  def planner_max_turns(self) -> int:
+    return self._config.planner.max_turns
+
+  @property
+  def executor_max_turns(self) -> int:
+    return self._config.executor.max_turns
+
+  async def plan(self, task: str, max_steps: int = 10) -> str:
+    """Generate a structured plan for *task*.
+
+    Returns a human-readable plan or an error message. The planner tool has
+    been removed from nonoka-agent in 1.3.4; a CLI-native planner will replace
+    this stub in a future release.
+    """
+    if not self.enabled:
+      return "Planning is disabled: no planner model configured."
+    return (
+      "Planning is disabled: the built-in planner tool was removed from "
+      "nonoka-agent 1.3.4. Configure a planner model to opt into the future "
+      "CLI-native planner implementation."
+    )
+
+
+def build_planning_service(
+  working_dir: Path,
+  config: CLIConfig | None = None,
+) -> PlanningService:
+  """Factory for creating a PlanningService from CLI configuration."""
+  agents_config = config.agents if config is not None else AgentsConfig()
+  default_model = config.model if config is not None else None
+  return PlanningService(
+    working_dir=working_dir,
+    config=agents_config,
+    default_model=default_model,
+  )

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/src/nonoka_cli/core/prompt_builder.py

@@ -181,20 +181,11 @@ class SystemPromptBuilder:
   def _build_planner_block(self) -> str:
     """Return guidance for the planner/executor workflow.
 
-    The ``plan_task`` sub-agent tool is injected only when ``agents.planner.model``
-    is configured. The workflow reminder is included so the model knows to use
-    planning for complex tasks and to synchronize progress with OpenCode's TODO
-    UI via ``todowrite``.
+    The built-in ``plan_task`` tool was removed from nonoka-agent in 1.3.4; the
+    planner block is currently suppressed until nonoka-cli provides its own
+    LLM-based planner implementation.
     """
-    if "plan_task" in self._base.lower():
-      return ""
-    return (
-      "## Planner / Executor Workflow\n"
-      "For complex multi-file or multi-step tasks, first call the ``plan_task`` "
-      "tool to produce a structured plan. Then execute the steps using the "
-      "file, search, and run-command tools. After each step, call ``todowrite`` "
-      "to update the TODO list so the user can follow progress in the OpenCode TUI."
-    )
+    return ""
 
   def _build_execution_plan_block(self) -> str:
     """Return the concrete execution plan produced by the planner agent."""

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/src/nonoka_cli/tools/builtins/agent_tools.py

@@ -1,9 +1,9 @@
 """Agent-level tools re-exported from nonoka-agent.
 
 These tools are implemented in nonoka-agent (the core agent framework) and are
-made available to every nonoka-cli Agent. The ``plan_task`` tool has been moved
-to ``nonoka_cli.core.planning_service`` and is injected as a sub-agent AgentTool
-by the Orchestrator when ``agents.planner.model`` is configured.
+made available to every nonoka-cli Agent. Keeping the implementation in
+nonoka-agent lets other consumers reuse them, while this module declares the
+subset the CLI exposes by default.
 """
 
 from __future__ import annotations

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/tests/unit/commands/test_opencode_cmd.py

@@ -151,28 +151,3 @@ def test_opencode_init_disables_native_skill_tool(tmp_path: Path):
 
   data = json.loads((tmp_path / "opencode.json").read_text())
   assert data.get("tools", {}).get("skill") is False
-
-
-def test_opencode_init_permissions_override(tmp_path: Path):
-  config_path = tmp_path / "nonoka.yaml"
-  ConfigLoader.save(
-    CLIConfig(
-      model="deepseek-chat",
-      permissions={"read": "allow", "bash": "ask"},
-    ),
-    config_path,
-  )
-
-  args = argparse.Namespace(
-    config=str(config_path),
-    cwd=str(tmp_path),
-    global_=False,
-  )
-  assert cmd_init(args) == 0
-
-  data = json.loads((tmp_path / "opencode.json").read_text())
-  assert data["permission"]["read"] == "allow"
-  assert data["permission"]["bash"] == "ask"
-  assert data["permission"]["write"] == "ask"
-  assert data["agent"]["build"]["permission"]["read"] == "allow"
-  assert data["agent"]["build"]["permission"]["bash"] == "ask"

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/tests/unit/config/test_models.py

@@ -1,7 +1,6 @@
 from pathlib import Path
 
 from nonoka_cli.config.models import (
-  AgentsConfig,
   CLIBehaviorConfig,
   CLIConfig,
   HITLConfigModel,
@@ -21,9 +20,7 @@ def test_cli_behavior_defaults():
 def test_cli_config_defaults():
   cfg = CLIConfig()
   assert cfg.model == "gpt-4o"
-  assert cfg.max_turns == 20
   assert cfg.system_prompt == ""
-  assert cfg.permissions == {}
   assert cfg.mcp_servers == {}
   assert cfg.tool_paths == []
   assert cfg.skills == []
@@ -31,30 +28,6 @@ def test_cli_config_defaults():
   assert isinstance(cfg.hitl, HITLConfigModel)
 
 
-def test_agents_config_has_no_executor():
-  cfg = AgentsConfig()
-  assert hasattr(cfg, "planner")
-  assert hasattr(cfg, "reviewer")
-  assert not hasattr(cfg, "executor")
-
-
-def test_cli_config_ignores_legacy_executor():
-  # Existing nonoka.yaml files may still contain agents.executor; Pydantic
-  # should ignore it rather than crash.
-  data = {
-    "model": "deepseek-chat",
-    "agents": {
-      "planner": {"model": "gpt-4o-mini"},
-      "executor": {"model": "gpt-4o", "max_turns": 10},
-      "reviewer": {"model": "gpt-4o-mini"},
-    },
-  }
-  cfg = CLIConfig.model_validate(data)
-  assert cfg.max_turns == 20
-  assert cfg.agents.planner.model == "gpt-4o-mini"
-  assert not hasattr(cfg.agents, "executor")
-
-
 def test_cli_config_tool_paths_expanded():
   cfg = CLIConfig(tool_paths=["~/tools", "./local_tools"])
   assert cfg.tool_paths[0] == Path.home() / "tools"

{nonoka_cli-0.2.5 → nonoka_cli-0.2.6}/tests/unit/core/test_agent_factory.py

@@ -415,49 +415,3 @@ async def test_build_with_external_tools_no_warning_when_native_skill_disabled(t
   agent = factory.build_with_external_tools(tools, cwd=str(tmp_path))
   prompt = agent.system_prompt
   assert "OpenCode's native skill tool is enabled" not in prompt
-
-
-class _FakeExtraTool:
-  """Minimal capability stand-in for extra_tools injection tests."""
-
-  name = "extra_tool"
-  description = "An extra tool"
-
-  @property
-  def parameters(self) -> dict:
-    return {"type": "object", "properties": {}}
-
-  async def invoke(self, ctx, arguments):
-    return "ok"
-
-  def to_json_schema(self):
-    return {
-      "type": "function",
-      "function": {"name": self.name, "description": self.description, "parameters": {}},
-    }
-
-
-@pytest.mark.asyncio
-async def test_build_injects_extra_tools():
-  config = CLIConfig(model="gpt-4o")
-  factory = AgentFactory(config)
-  agent = factory.build(extra_tools=[_FakeExtraTool()])
-  tool_names = {t.name for t in agent.tools}
-  assert "extra_tool" in tool_names
-
-
-@pytest.mark.asyncio
-async def test_build_with_external_tools_injects_extra_tools():
-  config = CLIConfig(model="gpt-4o")
-  factory = AgentFactory(config)
-  tools = [
-    AgentFactory.create_external_tool_capability(
-      name="bash",
-      description="Run shell commands",
-      parameters={"type": "object", "properties": {}},
-    )
-  ]
-  agent = factory.build_with_external_tools(tools, extra_tools=[_FakeExtraTool()])
-  tool_names = {t.name for t in agent.tools}
-  assert "bash" in tool_names
-  assert "extra_tool" in tool_names

nonoka_cli-0.2.6/tests/unit/core/test_orchestrator.py

@@ -0,0 +1,98 @@
+"""Tests for Orchestrator two-stage planning integration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from nonoka_cli.config.models import CLIConfig
+from nonoka_cli.core.orchestrator import Orchestrator
+
+
+@pytest.fixture
+def base_orchestrator(tmp_path: Path) -> Orchestrator:
+  """Return a minimally initialized orchestrator with mocked services."""
+  config = CLIConfig(
+    model="gpt-4o",
+    agents={
+      "planner": {"model": "gpt-4o-mini", "max_turns": 3, "system_prompt": ""},
+      "executor": {"model": "gpt-4o", "max_turns": 10, "system_prompt": ""},
+    },
+  )
+  orch = Orchestrator(config=config)
+  orch._initialized = True
+  orch._session_service = MagicMock()
+  orch._session_service.current_id = "test-session"
+  orch._session_service.manager = SimpleNamespace(db_path=tmp_path / "nonoka.db")
+  orch._runner_service = MagicMock()
+  orch._agent_factory = MagicMock()
+  orch._agent_factory.get_agent.return_value = MagicMock()
+  orch._config = config
+  return orch
+
+
+@pytest.mark.asyncio
+async def test_execute_with_external_tools_injects_execution_plan(
+  base_orchestrator: Orchestrator,
+) -> None:
+  """When planning is enabled, the generated plan is passed to the agent factory."""
+  orch = base_orchestrator
+
+  planning_service = MagicMock()
+  planning_service.enabled = True
+  planning_service.planner_model = "gpt-4o-mini"
+  planning_service.plan = AsyncMock(return_value="1. Do X\n2. Do Y")
+  orch._planning_service = planning_service
+
+  async def _fake_stream(*args, **kwargs):
+    yield MagicMock(type="final", data={"success": True})
+
+  orch._runner_service.run = MagicMock(side_effect=_fake_stream)
+
+  events = []
+  async for event in orch.execute_with_external_tools(
+    prompt="Create a test file",
+    tools=[],
+    working_dir=Path.cwd(),
+    host_system_prompt="Host prompt",
+  ):
+    events.append(event)
+
+  planning_service.plan.assert_awaited_once_with("Create a test file")
+  call_kwargs = orch._agent_factory.build_with_external_tools.call_args.kwargs
+  assert call_kwargs.get("execution_plan") == "1. Do X\n2. Do Y"
+
+
+@pytest.mark.asyncio
+async def test_execute_with_external_tools_skips_planning_when_disabled(
+  base_orchestrator: Orchestrator,
+) -> None:
+  """When no planner model is configured, no plan is generated."""
+  orch = base_orchestrator
+
+  planning_service = MagicMock()
+  planning_service.enabled = False
+  planning_service.planner_model = ""
+  planning_service.plan = AsyncMock(return_value="should not be used")
+  orch._planning_service = planning_service
+
+  async def _fake_stream(*args, **kwargs):
+    yield MagicMock(type="final", data={"success": True})
+
+  orch._runner_service.run = MagicMock(side_effect=_fake_stream)
+
+  events = []
+  async for event in orch.execute_with_external_tools(
+    prompt="Create a test file",
+    tools=[],
+    working_dir=Path.cwd(),
+    host_system_prompt="Host prompt",
+  ):
+    events.append(event)
+
+  planning_service.plan.assert_not_awaited()
+  call_kwargs = orch._agent_factory.build_with_external_tools.call_args.kwargs
+  assert call_kwargs.get("execution_plan") is None

nonoka_cli-0.2.6/tests/unit/core/test_planning_service.py

@@ -0,0 +1,40 @@
+"""Tests for PlanningService."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from nonoka_cli.config.models import AgentsConfig, AgentRoleConfig, CLIConfig
+from nonoka_cli.core.planning_service import PlanningService, build_planning_service
+
+
+def test_planner_model_prefers_configured() -> None:
+  config = AgentsConfig(
+    planner=AgentRoleConfig(model="gpt-4o-mini"),
+    executor=AgentRoleConfig(model="gpt-4o"),
+  )
+  service = PlanningService(working_dir=Path("."), config=config, default_model="fallback")
+  assert service.planner_model == "gpt-4o-mini"
+  assert service.executor_model == "gpt-4o"
+
+
+def test_planner_model_falls_back_to_default() -> None:
+  config = AgentsConfig()
+  service = PlanningService(working_dir=Path("."), config=config, default_model="fallback")
+  assert service.planner_model == "fallback"
+
+
+def test_disabled_when_no_model() -> None:
+  service = PlanningService(working_dir=Path("."), config=AgentsConfig())
+  assert not service.enabled
+
+
+def test_build_from_config() -> None:
+  config = CLIConfig(model="base-model", agents=AgentsConfig(
+    planner=AgentRoleConfig(model="planner-model"),
+  ))
+  service = build_planning_service(working_dir=Path("."), config=config)
+  assert service.planner_model == "planner-model"
+  assert service.executor_model == "base-model"