drydock-cli 2.6.29__tar.gz → 2.6.30__tar.gz

{drydock_cli-2.6.29 → drydock_cli-2.6.30}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.29
-Summary: Drydock — nautical CLI coding agent
+Version: 2.6.30
+Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock
 Project-URL: Issues, https://github.com/fbobe321/drydock/issues
@@ -10,7 +10,7 @@ Author: Drydock contributors, Mistral AI (original)
 License: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
-Keywords: ai,cli,coding-assistant,developer-tools,drydock,llm,nautical
+Keywords: ai,cli,coding-assistant,developer-tools,drydock,gemma,llm,local-llm,tui,vllm
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -60,41 +60,123 @@ Description-Content-Type: text/markdown
 [![License](https://img.shields.io/github/license/fbobe321/drydock)](https://github.com/fbobe321/drydock/blob/main/LICENSE)
 
 ```
-         |    |    |
-        )_)  )_)  )_)
-       )___))___))___)\
-      )____)____)_____)\\
-    _____|____|____|____\\\__
----\                   /----
-    \_________________/
-  ~~~~ ~~~ ~~~~ ~~~ ~~~~
-   ~~~ ~~~~ ~~~ ~~~ ~~~
+     ____                 _             _    
+    |  _ \ _ __ _   _  __| | ___   ___ | | __
+    | | | | '__| | | |/ _` |/ _ \ / __|| |/ /
+    | |_| | |  | |_| | (_| | (_) | (__ |   < 
+    |____/|_|   \__, |\__,_|\___/ \___||_|\_\
+                |___/
 ```
 
-**Nautical CLI coding agent. Chart your course. Execute with precision.**
+**Local-first CLI coding agent. Chart your course. Execute with precision.**
 
-DryDock is a command-line coding assistant that works with any LLM provider. It provides a conversational interface to your codebase, allowing you to use natural language to explore, modify, and interact with your projects through a powerful set of tools.
+DryDock is a TUI coding assistant designed to work with **local LLMs**. It provides a conversational interface to your codebase — explore, modify, build, and test projects through natural language and a powerful set of tools.
 
-> [!WARNING]
-> DryDock works on Windows, but we officially support and target UNIX environments.
+> [!IMPORTANT]
+> DryDock is tested and optimized for **Gemma 4 26B-A4B** (26B MoE, 4B active parameters) served via vLLM. Other models and providers are supported (Mistral, OpenAI, Anthropic, Ollama) but are not as thoroughly tested. If you use a different model, expect to tune prompts and tool settings.
 
-### Install
+## Tested Hardware + Model
+
+| Component | Spec |
+|-----------|------|
+| GPUs | 2x NVIDIA RTX 4060 Ti 16GB |
+| Model | [Gemma-4-26B-A4B-it-AWQ-4bit](https://huggingface.co/casperhansen/gemma-4-26b-a4b-it-AWQ-4bit) |
+| Serving | vLLM (Docker image `vllm/vllm-openai:gemma4`) |
+| Performance | ~70 tok/s, 131K context, 0% timeouts |
+| Active params | 4B per token (MoE architecture — fast inference) |
+
+### Install the model
+
+```bash
+# Download the model weights (requires HuggingFace access)
+pip install huggingface-hub
+huggingface-cli download casperhansen/gemma-4-26b-a4b-it-AWQ-4bit \
+    --local-dir /path/to/models/Gemma-4-26B-A4B-it-AWQ-4bit
+```
+
+### Start vLLM
+
+```bash
+docker run -d \
+    --gpus all \
+    --name gemma4 \
+    -p 8000:8000 \
+    -v /path/to/models:/models \
+    --ipc=host \
+    vllm/vllm-openai:gemma4 \
+    --model /models/Gemma-4-26B-A4B-it-AWQ-4bit \
+    --quantization compressed-tensors \
+    --tensor-parallel-size 2 \
+    --max-model-len 131072 \
+    --max-num-seqs 2 \
+    --gpu-memory-utilization 0.95 \
+    --kv-cache-dtype fp8 \
+    --served-model-name gemma4 \
+    --trust-remote-code \
+    --tool-call-parser gemma4 \
+    --enable-auto-tool-choice \
+    --attention-backend TRITON_ATTN
+```
+
+Key flags:
+- `--tensor-parallel-size 2` — split across 2 GPUs
+- `--kv-cache-dtype fp8` — reduce KV cache memory for longer contexts
+- `--tool-call-parser gemma4` + `--enable-auto-tool-choice` — required for Gemma 4 tool calling
+- `--max-num-seqs 2` — limit concurrent requests (prevents OOM on 16GB GPUs)
+
+Verify the model is running:
+```bash
+curl http://localhost:8000/v1/models
+```
+
+### Configure DryDock
+
+```toml
+# ~/.drydock/config.toml
+[models.gemma4]
+name = "gemma4"
+provider = "generic-openai"
+alias = "gemma4"
+temperature = 0.2
+thinking = "high"
+
+[providers.generic-openai]
+api_base = "http://localhost:8000/v1"
+api_style = "openai"
+```
+
+## Install
 
 ```bash
 pip install drydock-cli
 ```
 
 Or with uv:
-
 ```bash
 uv tool install drydock-cli
 ```
 
+## Quick Start
+
+```bash
+cd your-project/
+drydock
+```
+
+First run creates a config at `~/.drydock/config.toml` and prompts for your provider setup.
+
+```
+> Review the PRD and build the package
+```
+
 ## Features
 
-- **Interactive Chat**: A conversational AI agent that understands your requests and breaks down complex tasks.
-- **Powerful Toolset**: Read, write, and patch files. Execute shell commands. Search code with `grep`. Manage todos. Delegate to subagents.
-- **Project-Aware Context**: DryDock automatically scans your project's file structure and Git status.
+- **TUI Interface**: Full terminal UI with streaming output, tool approval, and session management.
+- **Adaptive Thinking**: Automatically adjusts reasoning depth per turn — full thinking for planning, fast mode for file writes.
+- **Powerful Toolset**: Read, write, and patch files. Execute shell commands. Search code with `grep`. Delegate to subagents.
+- **Project-Aware**: Scans project structure, loads `AGENTS.md` / `DRYDOCK.md` for context.
+- **Subagent Delegation**: Large tasks can be delegated to builder/planner/explorer subagents with isolated context.
+- **Loop Detection**: Advisory-only detection that nudges the model away from repetitive actions without blocking.
 - **Conda/Pip Support**: Auto-approves `pip install`, `conda install`, `pytest`, and other dev commands.
 - **Bundled Skills**: Ships with skills like `create-presentation` for PowerPoint generation.
 - **MCP Support**: Connect Model Context Protocol servers for extended capabilities.
@@ -111,21 +193,16 @@ uv tool install drydock-cli
 drydock --agent plan
 ```
 
-## Quick Start
+### Gemma 4 Optimizations
 
-1. Navigate to your project directory and run:
+DryDock includes several optimizations specifically tuned for Gemma 4:
 
-   ```bash
-   drydock
-   ```
-
-2. First run creates a config at `~/.drydock/config.toml` and prompts for your API key.
-
-3. Start chatting:
-
-   ```
-   > Can you find all TODO comments in this project?
-   ```
+- **Simplified prompt** (`gemma4.md`): 20-line system prompt instead of 125 lines. Complex prompts cause Gemma 4 to plan instead of act.
+- **Non-streaming mode**: Streaming breaks Gemma 4 tool call JSON parsing. DryDock automatically disables streaming for Gemma 4.
+- **Thinking token filtering**: Gemma 4 leaks `<|channel>thought<channel|>` tokens into text output. DryDock strips these before storing in context.
+- **Adaptive thinking**: Full thinking for planning (turn 1) and error recovery. Thinking OFF for routine file writes — eliminates 30-120s hangs between files.
+- **search_replace resilience**: Auto-detects already-applied edits, infers missing file paths, fuzzy-matches whitespace differences.
+- **Reduced tool set**: Disables tools that confuse Gemma 4 (`ask_user_question`, `task_create`, etc.).
 
 ## Usage
 
@@ -153,10 +230,6 @@ drydock --prompt "Analyze the codebase" --max-turns 5 --output json
 drydock --dangerously-skip-permissions -p "Fix all lint errors"
 ```
 
-### Trust Folder System
-
-DryDock includes a trust folder system. When you run DryDock in a directory with a `.drydock` folder, it asks you to confirm trust. Managed via `~/.drydock/trusted_folders.toml`.
-
 ## Configuration
 
 DryDock is configured via `config.toml`. It looks first in `./.drydock/config.toml`, then `~/.drydock/config.toml`.
@@ -175,11 +248,10 @@ Keys are saved to `~/.drydock/.env`.
 Set a smarter model for the `/consult` command:
 
 ```toml
-# In ~/.drydock/config.toml
 consultant_model = "gemini-2.5-pro"
 ```
 
-The consultant provides read-only advice — it never calls tools. Use `/consult <question>` to ask it. The response appears in your conversation so the local model can see it.
+The consultant provides read-only advice — it never calls tools. Use `/consult <question>` to ask it.
 
 ### Custom Agents
 
@@ -192,18 +264,6 @@ system_prompt_id = "redteam"
 disabled_tools = ["search_replace", "write_file"]
 ```
 
-```bash
-drydock --agent redteam
-```
-
-### Custom Prompts
-
-Create markdown files in `~/.drydock/prompts/`:
-
-```toml
-system_prompt_id = "my_custom_prompt"
-```
-
 ### Skills
 
 DryDock discovers skills from:
@@ -222,13 +282,27 @@ command = "uvx"
 args = ["mcp-server-fetch"]
 ```
 
-### Custom DryDock Home
+## Testing
+
+DryDock uses a **shakedown harness** (`scripts/shakedown.py`) that drives the real TUI via pexpect and judges on user-perceptible criteria — not tool-call counts.
 
 ```bash
-export DRYDOCK_HOME="/path/to/custom/home"
+# Single project test
+python3 scripts/shakedown.py \
+    --cwd /path/to/project \
+    --prompt "review the PRD and build the package" \
+    --pkg package_name
+
+# Interactive back-and-forth test
+python3 scripts/shakedown_interactive.py \
+    --cwd /path/to/project \
+    --pkg package_name
+
+# Full regression suite (370 PRDs)
+bash scripts/shakedown_suite.sh
 ```
 
-This affects where DryDock looks for `config.toml`, `.env`, `agents/`, `prompts/`, `skills/`, and `logs/`.
+Pass criteria: no write loops, no ignored interrupts, no search_replace cascades, package executes, session finishes within time budget.
 
 ## Slash Commands
 
@@ -242,12 +316,6 @@ drydock --resume abc123         # Resume specific session
 drydock --workdir /path/to/dir  # Set working directory
 ```
 
-## Resources
-
-- [CHANGELOG](CHANGELOG.md)
-- [CONTRIBUTING](CONTRIBUTING.md)
-- [ACP Setup](docs/acp-setup.md) — Editor/IDE integration
-
 ## License
 
 Copyright 2025 Mistral AI (original work)

drydock_cli-2.6.30/README.md

@@ -0,0 +1,270 @@
+# DryDock
+
+[![Python Version](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/downloads/release/python-3120/)
+[![License](https://img.shields.io/github/license/fbobe321/drydock)](https://github.com/fbobe321/drydock/blob/main/LICENSE)
+
+```
+     ____                 _             _    
+    |  _ \ _ __ _   _  __| | ___   ___ | | __
+    | | | | '__| | | |/ _` |/ _ \ / __|| |/ /
+    | |_| | |  | |_| | (_| | (_) | (__ |   < 
+    |____/|_|   \__, |\__,_|\___/ \___||_|\_\
+                |___/
+```
+
+**Local-first CLI coding agent. Chart your course. Execute with precision.**
+
+DryDock is a TUI coding assistant designed to work with **local LLMs**. It provides a conversational interface to your codebase — explore, modify, build, and test projects through natural language and a powerful set of tools.
+
+> [!IMPORTANT]
+> DryDock is tested and optimized for **Gemma 4 26B-A4B** (26B MoE, 4B active parameters) served via vLLM. Other models and providers are supported (Mistral, OpenAI, Anthropic, Ollama) but are not as thoroughly tested. If you use a different model, expect to tune prompts and tool settings.
+
+## Tested Hardware + Model
+
+| Component | Spec |
+|-----------|------|
+| GPUs | 2x NVIDIA RTX 4060 Ti 16GB |
+| Model | [Gemma-4-26B-A4B-it-AWQ-4bit](https://huggingface.co/casperhansen/gemma-4-26b-a4b-it-AWQ-4bit) |
+| Serving | vLLM (Docker image `vllm/vllm-openai:gemma4`) |
+| Performance | ~70 tok/s, 131K context, 0% timeouts |
+| Active params | 4B per token (MoE architecture — fast inference) |
+
+### Install the model
+
+```bash
+# Download the model weights (requires HuggingFace access)
+pip install huggingface-hub
+huggingface-cli download casperhansen/gemma-4-26b-a4b-it-AWQ-4bit \
+    --local-dir /path/to/models/Gemma-4-26B-A4B-it-AWQ-4bit
+```
+
+### Start vLLM
+
+```bash
+docker run -d \
+    --gpus all \
+    --name gemma4 \
+    -p 8000:8000 \
+    -v /path/to/models:/models \
+    --ipc=host \
+    vllm/vllm-openai:gemma4 \
+    --model /models/Gemma-4-26B-A4B-it-AWQ-4bit \
+    --quantization compressed-tensors \
+    --tensor-parallel-size 2 \
+    --max-model-len 131072 \
+    --max-num-seqs 2 \
+    --gpu-memory-utilization 0.95 \
+    --kv-cache-dtype fp8 \
+    --served-model-name gemma4 \
+    --trust-remote-code \
+    --tool-call-parser gemma4 \
+    --enable-auto-tool-choice \
+    --attention-backend TRITON_ATTN
+```
+
+Key flags:
+- `--tensor-parallel-size 2` — split across 2 GPUs
+- `--kv-cache-dtype fp8` — reduce KV cache memory for longer contexts
+- `--tool-call-parser gemma4` + `--enable-auto-tool-choice` — required for Gemma 4 tool calling
+- `--max-num-seqs 2` — limit concurrent requests (prevents OOM on 16GB GPUs)
+
+Verify the model is running:
+```bash
+curl http://localhost:8000/v1/models
+```
+
+### Configure DryDock
+
+```toml
+# ~/.drydock/config.toml
+[models.gemma4]
+name = "gemma4"
+provider = "generic-openai"
+alias = "gemma4"
+temperature = 0.2
+thinking = "high"
+
+[providers.generic-openai]
+api_base = "http://localhost:8000/v1"
+api_style = "openai"
+```
+
+## Install
+
+```bash
+pip install drydock-cli
+```
+
+Or with uv:
+```bash
+uv tool install drydock-cli
+```
+
+## Quick Start
+
+```bash
+cd your-project/
+drydock
+```
+
+First run creates a config at `~/.drydock/config.toml` and prompts for your provider setup.
+
+```
+> Review the PRD and build the package
+```
+
+## Features
+
+- **TUI Interface**: Full terminal UI with streaming output, tool approval, and session management.
+- **Adaptive Thinking**: Automatically adjusts reasoning depth per turn — full thinking for planning, fast mode for file writes.
+- **Powerful Toolset**: Read, write, and patch files. Execute shell commands. Search code with `grep`. Delegate to subagents.
+- **Project-Aware**: Scans project structure, loads `AGENTS.md` / `DRYDOCK.md` for context.
+- **Subagent Delegation**: Large tasks can be delegated to builder/planner/explorer subagents with isolated context.
+- **Loop Detection**: Advisory-only detection that nudges the model away from repetitive actions without blocking.
+- **Conda/Pip Support**: Auto-approves `pip install`, `conda install`, `pytest`, and other dev commands.
+- **Bundled Skills**: Ships with skills like `create-presentation` for PowerPoint generation.
+- **MCP Support**: Connect Model Context Protocol servers for extended capabilities.
+- **Safety First**: Tool execution approval with `--dangerously-skip-permissions` for full auto-approve.
+
+### Built-in Agents
+
+- **`default`**: Standard agent that requires approval for tool executions.
+- **`plan`**: Read-only agent for exploration and planning.
+- **`accept-edits`**: Auto-approves file edits only.
+- **`auto-approve`**: Auto-approves all tool executions.
+
+```bash
+drydock --agent plan
+```
+
+### Gemma 4 Optimizations
+
+DryDock includes several optimizations specifically tuned for Gemma 4:
+
+- **Simplified prompt** (`gemma4.md`): 20-line system prompt instead of 125 lines. Complex prompts cause Gemma 4 to plan instead of act.
+- **Non-streaming mode**: Streaming breaks Gemma 4 tool call JSON parsing. DryDock automatically disables streaming for Gemma 4.
+- **Thinking token filtering**: Gemma 4 leaks `<|channel>thought<channel|>` tokens into text output. DryDock strips these before storing in context.
+- **Adaptive thinking**: Full thinking for planning (turn 1) and error recovery. Thinking OFF for routine file writes — eliminates 30-120s hangs between files.
+- **search_replace resilience**: Auto-detects already-applied edits, infers missing file paths, fuzzy-matches whitespace differences.
+- **Reduced tool set**: Disables tools that confuse Gemma 4 (`ask_user_question`, `task_create`, etc.).
+
+## Usage
+
+### Interactive Mode
+
+```bash
+drydock                        # Start interactive session
+drydock "Fix the login bug"    # Start with a prompt
+drydock --continue             # Resume last session
+drydock --resume abc123        # Resume specific session
+```
+
+**Keyboard shortcuts:**
+- `Ctrl+C` — Cancel current operation (double-tap to quit)
+- `Shift+Tab` — Toggle auto-approve mode
+- `Ctrl+O` — Toggle tool output
+- `Ctrl+G` — Open external editor
+- `@` — File path autocompletion
+- `!command` — Run shell command directly
+
+### Programmatic Mode
+
+```bash
+drydock --prompt "Analyze the codebase" --max-turns 5 --output json
+drydock --dangerously-skip-permissions -p "Fix all lint errors"
+```
+
+## Configuration
+
+DryDock is configured via `config.toml`. It looks first in `./.drydock/config.toml`, then `~/.drydock/config.toml`.
+
+### API Key
+
+```bash
+drydock --setup                              # Interactive setup
+export MISTRAL_API_KEY="your_key"            # Or set env var
+```
+
+Keys are saved to `~/.drydock/.env`.
+
+### Consultant Model
+
+Set a smarter model for the `/consult` command:
+
+```toml
+consultant_model = "gemini-2.5-pro"
+```
+
+The consultant provides read-only advice — it never calls tools. Use `/consult <question>` to ask it.
+
+### Custom Agents
+
+Create agent configs in `~/.drydock/agents/`:
+
+```toml
+# ~/.drydock/agents/redteam.toml
+active_model = "devstral-2"
+system_prompt_id = "redteam"
+disabled_tools = ["search_replace", "write_file"]
+```
+
+### Skills
+
+DryDock discovers skills from:
+1. Custom paths in `config.toml` via `skill_paths`
+2. Project `.drydock/skills/` or `.agents/skills/`
+3. Global `~/.drydock/skills/`
+4. Bundled skills (shipped with the package)
+
+### MCP Servers
+
+```toml
+[[mcp_servers]]
+name = "fetch_server"
+transport = "stdio"
+command = "uvx"
+args = ["mcp-server-fetch"]
+```
+
+## Testing
+
+DryDock uses a **shakedown harness** (`scripts/shakedown.py`) that drives the real TUI via pexpect and judges on user-perceptible criteria — not tool-call counts.
+
+```bash
+# Single project test
+python3 scripts/shakedown.py \
+    --cwd /path/to/project \
+    --prompt "review the PRD and build the package" \
+    --pkg package_name
+
+# Interactive back-and-forth test
+python3 scripts/shakedown_interactive.py \
+    --cwd /path/to/project \
+    --pkg package_name
+
+# Full regression suite (370 PRDs)
+bash scripts/shakedown_suite.sh
+```
+
+Pass criteria: no write loops, no ignored interrupts, no search_replace cascades, package executes, session finishes within time budget.
+
+## Slash Commands
+
+Type `/help` in the input for available commands. Create custom slash commands via the skills system.
+
+## Session Management
+
+```bash
+drydock --continue              # Continue last session
+drydock --resume abc123         # Resume specific session
+drydock --workdir /path/to/dir  # Set working directory
+```
+
+## License
+
+Copyright 2025 Mistral AI (original work)
+Copyright 2026 DryDock contributors (modifications)
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.
+
+DryDock is a fork of [mistralai/mistral-vibe](https://github.com/mistralai/mistral-vibe) (Apache 2.0). See [NOTICE](NOTICE) for attribution.

{drydock_cli-2.6.29 → drydock_cli-2.6.30}/drydock/core/agent_loop.py

@@ -1420,6 +1420,56 @@ class AgentLoop:
         if self.messages and self.messages[-1].role == Role.assistant:
             self.messages.append(LLMMessage(role=Role.user, content="Continue."))
 
+    def _choose_thinking_level(self, active_model: Any) -> str:
+        """Adapt thinking level based on conversation state.
+
+        Thinking is expensive for Gemma 4 (~70 tok/s).  Using "high" on
+        every turn causes 30-120s hangs between file writes.  Instead:
+
+        HIGH — first response, user messages, planning/complex decisions
+        LOW  — after tool errors (debug, but keep it brief)
+        OFF  — after successful tool results, system notes (just act)
+        """
+        base = active_model.thinking
+        if base in ("off", ""):
+            return base  # thinking disabled entirely — respect that
+
+        # Only adapt for local models where thinking is slow
+        if "gemma" not in active_model.name.lower():
+            return base
+
+        # Early conversation (first few turns): full thinking for planning
+        # The model needs to understand the task and make a plan.
+        if len(self.messages) <= 4:
+            return base
+
+        # Look at the last message to decide
+        last = self.messages[-1] if self.messages else None
+        if last is None:
+            return base
+
+        if last.role == Role.user:
+            content = str(last.content or "")
+            # System note / loop nudge → act immediately
+            if "[SYSTEM" in content:
+                return "off"
+            # Real user message → full thinking (they're asking something new)
+            return base
+
+        if last.role == Role.tool:
+            content = str(last.content or "")
+            # Tool error → think about the fix (but not too long)
+            if "<tool_error>" in content or "error" in content.lower()[:100]:
+                return "low"
+            # read_file result → might need to reason about the code
+            if "content:" in content[:50] and len(content) > 500:
+                return "low"
+            # Successful write/bash → just keep going
+            return "off"
+
+        # Default: configured level
+        return base
+
     async def _chat(self, max_tokens: int | None = None) -> LLMChunk:
         _t0 = time.perf_counter()
         self._sanitize_message_ordering()
@@ -1439,16 +1489,20 @@ class AgentLoop:
             _t1 - _t0, _t2 - _t1, n_msgs, n_tools,
         )
 
+        # Adaptive thinking: reduce thinking on routine turns
+        original_thinking = active_model.thinking
+        active_model.thinking = self._choose_thinking_level(active_model)
+        if active_model.thinking != original_thinking:
+            logger.info(
+                "[THINKING] %s → %s (last msg role=%s)",
+                original_thinking, active_model.thinking,
+                self.messages[-1].role if self.messages else "?",
+            )
+
         try:
             start_time = time.perf_counter()
             # Use temperature override if set (loop detection bumps it)
             temp = active_model.temperature
-            # Cap max_tokens for Gemma 4 to prevent infinite thinking loops.
-            # Without a cap, the model can generate 100K+ thinking tokens
-            # (filling the 131K context), hanging for 20+ minutes per turn.
-            effective_max_tokens = max_tokens
-            if effective_max_tokens is None and "gemma" in active_model.name.lower():
-                effective_max_tokens = 8192
             result = await self.backend.complete(
                 model=active_model,
                 messages=self.messages,
@@ -1456,7 +1510,7 @@ class AgentLoop:
                 tools=available_tools,
                 tool_choice=tool_choice,
                 extra_headers=self._get_extra_headers(provider),
-                max_tokens=effective_max_tokens,
+                max_tokens=max_tokens,
                 metadata=self.entrypoint_metadata.model_dump()
                 if self.entrypoint_metadata
                 else None,
@@ -1488,6 +1542,9 @@ class AgentLoop:
             raise RuntimeError(
                 f"API error from {provider.name} (model: {active_model.name}): {e}"
             ) from e
+        finally:
+            # Restore thinking level so the config stays clean
+            active_model.thinking = original_thinking
 
     async def _chat_streaming(
         self, max_tokens: int | None = None

{drydock_cli-2.6.29 → drydock_cli-2.6.30}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "drydock-cli"
-version = "2.6.29"
-description = "Drydock — nautical CLI coding agent"
+version = "2.6.30"
+description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"
 license = { text = "Apache-2.0" }
@@ -11,9 +11,12 @@ keywords = [
     "cli",
     "coding-assistant",
     "drydock",
-    "nautical",
     "llm",
     "developer-tools",
+    "gemma",
+    "vllm",
+    "local-llm",
+    "tui",
 ]
 classifiers = [
     "Development Status :: 5 - Production/Stable",