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

{nonoka_cli-0.2.4 → 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.4 → nonoka_cli-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonoka-cli
-Version: 0.2.4
+Version: 0.2.6
 Summary: OpenCode backend for the Nonoka Agent framework
 License: MIT
 License-File: LICENSE
@@ -51,7 +51,7 @@ The installer will:
 3. Install `nonoka-cli` and the OpenCode provider.
 4. Generate `~/.config/nonoka/config.yaml` and `~/.config/opencode/opencode.json`.
 
-After installing, configure your API key and run `opencode`:
+After installing, configure your API key and run `nonoka`:
 
 ```bash
 # Interactive: it will ask for your key and save it to ~/.config/nonoka/.env
@@ -61,9 +61,13 @@ nonoka-cli config init
 export DEEPSEEK_API_KEY=<your-key>
 
 nonoka-cli doctor
-opencode
+nonoka
 ```
 
+`nonoka` is a shortcut for `nonoka-cli run` and starts the OpenCode TUI with the
+Nonoka backend. You can also use `nonoka run --message "<task>"` for one-shot
+CLI usage.
+
 `nonoka-cli` automatically loads `~/.config/nonoka/.env` and `./.env` on startup,
 so you don't need to `export` every time if you save the key in `.env`.
 
@@ -111,7 +115,7 @@ nonoka-cli opencode init --global
 3. Make sure your model API key is exported, then run:
 
 ```bash
-opencode
+nonoka
 ```
 
 ## `nonoka-cli doctor`
@@ -126,10 +130,10 @@ Example output:
 
 ```
 nonoka-cli doctor
-✓ nonoka-cli 0.2.4
+✓ nonoka-cli 0.2.5
 ✓ Python 3.11
-✓ opencode 1.17.13
-✓ provider nonoka-opencode-provider@0.2.4
+✓ opencode 1.18.2
+✓ provider nonoka-opencode-provider@0.2.12
 ✓ config ~/.config/nonoka/config.yaml
 ✓ API key DEEPSEEK_API_KEY set
 ✓ OpenCode provider config in /home/user/.config/opencode/opencode.json

{nonoka_cli-0.2.4 → nonoka_cli-0.2.6}/README.md

@@ -22,7 +22,7 @@ The installer will:
 3. Install `nonoka-cli` and the OpenCode provider.
 4. Generate `~/.config/nonoka/config.yaml` and `~/.config/opencode/opencode.json`.
 
-After installing, configure your API key and run `opencode`:
+After installing, configure your API key and run `nonoka`:
 
 ```bash
 # Interactive: it will ask for your key and save it to ~/.config/nonoka/.env
@@ -32,9 +32,13 @@ nonoka-cli config init
 export DEEPSEEK_API_KEY=<your-key>
 
 nonoka-cli doctor
-opencode
+nonoka
 ```
 
+`nonoka` is a shortcut for `nonoka-cli run` and starts the OpenCode TUI with the
+Nonoka backend. You can also use `nonoka run --message "<task>"` for one-shot
+CLI usage.
+
 `nonoka-cli` automatically loads `~/.config/nonoka/.env` and `./.env` on startup,
 so you don't need to `export` every time if you save the key in `.env`.
 
@@ -82,7 +86,7 @@ nonoka-cli opencode init --global
 3. Make sure your model API key is exported, then run:
 
 ```bash
-opencode
+nonoka
 ```
 
 ## `nonoka-cli doctor`
@@ -97,10 +101,10 @@ Example output:
 
 ```
 nonoka-cli doctor
-✓ nonoka-cli 0.2.4
+✓ nonoka-cli 0.2.5
 ✓ Python 3.11
-✓ opencode 1.17.13
-✓ provider nonoka-opencode-provider@0.2.4
+✓ opencode 1.18.2
+✓ provider nonoka-opencode-provider@0.2.12
 ✓ config ~/.config/nonoka/config.yaml
 ✓ API key DEEPSEEK_API_KEY set
 ✓ OpenCode provider config in /home/user/.config/opencode/opencode.json

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nonoka-cli"
-version = "0.2.4"
+version = "0.2.6"
 description = "OpenCode backend for the Nonoka Agent framework"
 readme = "README.md"
 license = { text = "MIT" }
@@ -29,6 +29,7 @@ dependencies = [
 
 [project.scripts]
 nonoka-cli = "nonoka_cli.cli:main"
+nonoka = "nonoka_cli.cli:main"
 
 [project.optional-dependencies]
 dev = [

{nonoka_cli-0.2.4 → 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.4 → nonoka_cli-0.2.6}/src/nonoka_cli/cli.py

@@ -26,7 +26,7 @@ import structlog
 from dotenv import load_dotenv
 
 from nonoka_cli.bridge.server import main as server_main
-from nonoka_cli.commands import config_cmd, doctor_cmd, opencode_cmd, plugin_cmd
+from nonoka_cli.commands import config_cmd, doctor_cmd, opencode_cmd, plugin_cmd, run_cmd
 from nonoka_cli.utils.logging import setup_logging
 
 logger = structlog.get_logger("nonoka_cli.cli")
@@ -88,6 +88,7 @@ def _build_parser() -> argparse.ArgumentParser:
   doctor_cmd.add_subparser(subparsers)
   opencode_cmd.add_subparser(subparsers)
   plugin_cmd.add_subparser(subparsers)
+  run_cmd.add_subparser(subparsers)
 
   return parser
 
@@ -116,16 +117,14 @@ def main() -> int:
     setup_logging(level=log_level, console=args.verbose or args.debug)
     return args.func(args)
 
+  # No subcommand given: launch the OpenCode TUI by default.
   log_level = (
     logging.DEBUG if args.debug
     else logging.INFO if args.verbose
     else logging.WARNING
   )
   setup_logging(level=log_level, console=args.verbose or args.debug)
-
-  print("nonoka-cli: use --server to start the OpenCode backend.", file=sys.stderr)
-  parser.print_help(sys.stderr)
-  return 0
+  return run_cmd.launch_tui(args)
 
 
 if __name__ == "__main__":

{nonoka_cli-0.2.4 → 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.6/src/nonoka_cli/commands/run_cmd.py

@@ -0,0 +1,110 @@
+"""Launch the OpenCode TUI from nonoka-cli."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from nonoka_cli.commands.opencode_cmd import cmd_init
+
+
+def _has_opencode() -> bool:
+    """Return True if the opencode binary is available on PATH."""
+    return shutil.which("opencode") is not None
+
+
+def _has_opencode_config(cwd: Path) -> bool:
+    """Return True if the directory already has an opencode.json."""
+    return (cwd / "opencode.json").exists()
+
+
+def _ensure_opencode_config(args: argparse.Namespace, cwd: Path) -> int:
+    """Initialize opencode.json if it is missing.
+
+    Returns:
+        0 if the config exists or was created successfully, otherwise an error code.
+    """
+    if _has_opencode_config(cwd):
+        return 0
+
+    print(f"No opencode.json found in {cwd}. Running 'nonoka-cli opencode init'...", file=sys.stderr)
+
+    init_args = argparse.Namespace(
+        config=getattr(args, "config", None),
+        cwd=str(cwd),
+        global_=False,
+        yes=True,
+        command="opencode",
+        opencode_command="init",
+    )
+    return cmd_init(init_args)
+
+
+def launch_tui(args: argparse.Namespace) -> int:
+    """Launch the OpenCode TUI in the requested directory.
+
+    If ``args.message`` is provided, run OpenCode in one-shot mode with
+    ``opencode run --auto <message>``. Otherwise start the interactive TUI.
+    """
+    cwd = Path(getattr(args, "cwd", ".")).expanduser().resolve()
+
+    if not _has_opencode():
+        print("Error: opencode is not installed.", file=sys.stderr)
+        print("Install it with: npm install -g opencode", file=sys.stderr)
+        return 1
+
+    ret = _ensure_opencode_config(args, cwd)
+    if ret != 0:
+        return ret
+
+    message = getattr(args, "message", None)
+    if message:
+        cmd = ["opencode", "run", "--auto", message]
+    else:
+        cmd = ["opencode", str(cwd)]
+
+    try:
+        result = subprocess.run(cmd, cwd=cwd)
+        return result.returncode
+    except KeyboardInterrupt:
+        return 130
+    except FileNotFoundError:
+        print("Error: opencode disappeared during launch.", file=sys.stderr)
+        return 1
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    """Entry point for the ``nonoka-cli run`` subcommand."""
+    return launch_tui(args)
+
+
+def add_subparser(subparsers: Any) -> None:
+    """Register the ``run`` subcommand."""
+    run_parser = subparsers.add_parser(
+        "run",
+        help="Launch the OpenCode TUI (default when no subcommand is given)",
+    )
+    run_parser.add_argument(
+        "--config",
+        dest="config",
+        type=Path,
+        default=None,
+        help="Path to the nonoka config file (default: ~/.config/nonoka/config.yaml)",
+    )
+    run_parser.add_argument(
+        "--cwd",
+        dest="cwd",
+        default=".",
+        help="Directory to start OpenCode in (default: current directory)",
+    )
+    run_parser.add_argument(
+        "--message", "-m",
+        dest="message",
+        default=None,
+        help="Run a single message and exit instead of starting the interactive TUI",
+    )
+    run_parser.set_defaults(func=cmd_run)

{nonoka_cli-0.2.4 → 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.4 → 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.4 → 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.4 → 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.4 → 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.4 → 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"