drydock-cli 2.6.25__tar.gz → 2.6.27__tar.gz

drydock_cli-2.6.27/.auto_release.lock

@@ -0,0 +1 @@
+306344

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/CLAUDE.md

@@ -9,8 +9,8 @@ Drydock is a local CLI coding agent (fork of mistral-vibe, Apache 2.0).
 - **Hardware:** 2x RTX 4060 Ti 16GB, Gemma 4 26B MoE (A4B) via vLLM Docker at localhost:8000
 - **Server:** remus (Ubuntu 22.04, user: bobef)
 - **Active model:** Gemma 4 26B-A4B-it-AWQ-4bit (only 4B active params, ~70 tok/s)
-- **The honest test:** `scripts/user_pain_test.py` user-pain harness — pass means real
-  user-perceptible behaviour, not tool-call counts. See `scripts/run_pain_suite.sh`
+- **The honest test:** `scripts/shakedown.py` shakedown harness — pass means real
+  user-perceptible behaviour, not tool-call counts. See `scripts/shakedown_suite.sh`
   for the 10-project core set.
 - **OLD harnesses you should NOT trust:** `scripts/tui_test.py` and
   `core_tests_real.sh` count tool calls and `--help` and miss the things users
@@ -261,11 +261,11 @@ v3 is a from-scratch rewrite using nano-claude-code as foundation. 4 core files,
 - ✅ Docker-based model serving (vLLM + Gemma 4)
 - ✅ Multi-backend SWE-bench harness (v2/devstral + v3/gemma4)
 - ✅ Thinking token filtering (Gemma 4 `<|channel>` leak)
-- ✅ **User-pain harness** (`scripts/user_pain_test.py`) — drives real TUI
+- ✅ **Shakedown harness** (`scripts/shakedown.py`) — drives real TUI
   via pexpect, watches live session log, types `STOP` interrupts,
   judges on user-perceptible criteria
-- ✅ **Multi-PRD pain suite** (`scripts/run_pain_suite.sh`) — 10 core
-  projects through the user-pain harness
+- ✅ **Shakedown suite** (`scripts/shakedown_suite.sh`) — 10 core
+  projects through the shakedown harness
 - ✅ **`_check_main_module_entry`** in write_file.py — catches
   `__main__.py` files that import `main` but never call it (the codec
   silent-exit bug)
@@ -286,7 +286,7 @@ v3 is a from-scratch rewrite using nano-claude-code as foundation. 4 core files,
 - ✅ **`_task_manager.py` rename** — TaskCreate/Update/List were
   duplicates of the `todo` tool that confused Gemma 4 into hanging.
   Underscore prefix excludes them from tool discovery
-- ✅ **Trust dialog auto-dismissal** in user_pain_test.py
+- ✅ **Trust dialog auto-dismissal** in shakedown.py
 - ✅ **Pause flags** for both `auto_release.sh` and `watchdog.sh` so
   manual debugging doesn't get its work overwritten
 
@@ -301,7 +301,7 @@ v3 is a from-scratch rewrite using nano-claude-code as foundation. 4 core files,
    loop, hang, and produce broken code. The harnesses were structurally
    incapable of catching what users experience because they measure
    tool-call counts and `--help` exit codes, not progress. Build pass
-   criteria around user-perceptible state instead. See `user_pain_test.py`.
+   criteria around user-perceptible state instead. See `shakedown.py`.
 2. **Gemma 4 ignores advisory nudges.** The model received the dedup
    message ("File already has this exact content. Move to the NEXT file."),
    the loop-detection system note, the missing-import warning, AND a
@@ -384,9 +384,9 @@ v3 is a from-scratch rewrite using nano-claude-code as foundation. 4 core files,
 
 ## Testing
 
-### Use `scripts/user_pain_test.py` — anything else lies
+### Use `scripts/shakedown.py` — anything else lies
 
-The `user_pain_test.py` harness is the only test infrastructure that catches what
+The `shakedown.py` harness is the only test infrastructure that catches what
 real users experience. Older harnesses (`tui_test.py`, `core_tests_real.sh`,
 `run_real_tests.sh`) measure tool counts and `--help` exit codes; they pass
 while real users see loops and hangs.
@@ -416,7 +416,7 @@ while real users see loops and hangs.
 **Run a single project:**
 
 ```bash
-PYTHONUNBUFFERED=1 python3 -u scripts/user_pain_test.py \
+PYTHONUNBUFFERED=1 python3 -u scripts/shakedown.py \
     --cwd /data3/test_drydock \
     --prompt "review the PRD and get started" \
     --pkg doc_qa_system
@@ -425,7 +425,7 @@ PYTHONUNBUFFERED=1 python3 -u scripts/user_pain_test.py \
 **Run the 10-project core suite:**
 
 ```bash
-bash scripts/run_pain_suite.sh
+bash scripts/shakedown_suite.sh
 ```
 
 **Real-world results from the harness (after recent fixes):**
@@ -471,7 +471,7 @@ From `/data3/drydock_test_projects/X` it reports the site-packages path.
 **Always test imports from a neutral cwd**, OR commit to source AND let
 auto_release rebuild.
 
-### Test Levels (kept for reference, but the user-pain harness covers all of them)
+### Test Levels (kept for reference, but the shakedown harness covers all of them)
 1. **Build test (--help):** package runs — MEANINGLESS alone
 2. **Functional test:** PRD test cases verified with correct output — THE REAL TEST
 3. **Acceptance test:** specific expected outputs verified
@@ -485,7 +485,7 @@ auto_release rebuild.
 - The model should be able to answer questions without being forced to edit files
 - **NEVER trust an old harness's pass result.** If `tui_test.py` or
   `core_tests_real.sh` says PASS, run the same project through
-  `user_pain_test.py` to confirm. The old harnesses count `--help` and
+  `shakedown.py` to confirm. The old harnesses count `--help` and
   silently miss the things users hate.
 - **Always reset PRDs between runs.** The model edits PRD.md (adds
   "✅ Completed" status tables, chat-style filler) and contaminates

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.25
+Version: 2.6.27
 Summary: Drydock — nautical CLI coding agent
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

drydock_cli-2.6.27/PRD.md

@@ -0,0 +1,216 @@
+# DryDock — Local CLI Coding Agent
+
+**Repository:** https://github.com/fbobe321/drydock
+**PyPI:** https://pypi.org/project/drydock-cli/ (v2.6.25)
+**License:** Apache 2.0 (fork of [mistralai/mistral-vibe](https://github.com/mistralai/mistral-vibe))
+
+## Vision
+
+Best-in-class local coding agent. Build, debug, and ship software using local
+LLMs on consumer hardware — and **prove it actually works** with a test
+harness that drives the real TUI like a real user, not a tool-call counter.
+
+## Current Status
+
+- **Active model:** Gemma 4 26B-A4B-it-AWQ-4bit (MoE, 4B active params per
+  token, ~70 tok/s) via vLLM Docker on 2x RTX 4060 Ti 16GB
+- **Version:** 2.6.25 on PyPI (2.6.26+ in source with `slim_system_prompt`,
+  hard-block on duplicate writes, and the new test harness)
+- **Honest test results (10 core PRDs through `shakedown.py`, single run):**
+  5/10 PASS without slim_system_prompt + hard block; ≥8/10 expected with
+  both fixes deployed (variance run in progress)
+- **Users can:** build projects from PRDs, fix bugs, review code, refactor
+  — through the TUI only (headless mode is gone)
+
+## How drydock is tested now
+
+The `scripts/tui_test.py` and `core_tests_real.sh` harnesses count tool
+calls and `--help` exit codes. They reported 80% pass rates while real
+users saw drydock loop, hang, and produce broken code. **Both are
+deprecated** in favour of `scripts/shakedown.py`, which:
+
+- Drives the real `drydock` TUI via pexpect (no headless code paths)
+- Polls the live `~/.vibe/logs/session/session_<id>/messages.jsonl` in
+  parallel to see what the model is actually doing
+- Watches for **write loops** (≥3 identical-content writes to a path),
+  **hallucinated tool names** that hang the session, **search_replace
+  failure cascades**, and **dead silence** (no new messages of any kind
+  for 120 seconds)
+- Types simulated `STOP` interrupts when it detects loops and tracks
+  whether the model OBEYS them
+- Distinguishes three end-states: active turn, model declared done
+  (text response with no tool call), and dead silence
+- Resets the cwd between runs (restores `PRD.md` from `PRD.master.md`,
+  wipes the package dir and stale data dirs) so contamination from one
+  run can't poison the next
+- Auto-handles the "Trust this folder?" dialog drydock pops on new
+  directories
+- **Pass criteria are user-perceptible**: no loops, no ignored
+  interrupts, no search_replace cascades, the package must actually
+  execute, session must finish under the time budget
+
+Run a single project:
+
+```bash
+PYTHONUNBUFFERED=1 python3 -u scripts/shakedown.py \
+    --cwd /data3/test_drydock \
+    --prompt "review the PRD and get started" \
+    --pkg doc_qa_system
+```
+
+Run the 10-project core suite (or 3-run variance suite for stability):
+
+```bash
+bash scripts/shakedown_suite.sh        # one run, ~25 min
+bash scripts/shakedown_variance.sh 3   # three runs, ~75 min
+```
+
+## Features
+
+### Core
+- 24 builtin tools (bash, grep, read_file, write_file, search_replace,
+  glob, todo, ask_user_question, invoke_skill, worktree, etc.)
+- 7 bundled skills (/investigate, /review, /ship, /batch, /simplify,
+  /deep-research, /create-presentation)
+- Multi-agent delegation (explore, diagnostic, planner subagents)
+- Plan→Edit workflow (Mistral's designed pattern)
+- AGENTS.md support (cross-tool standard, auto-created — same file works
+  with Claude Code, opencode, drydock, Aider)
+- Textual TUI with wave spinner, message queuing
+
+### Local Model Support
+- `/setup-model` command (vLLM, Ollama, LM Studio, custom)
+- `--local` CLI flag for quick setup
+- Auto-detect model name from server
+- **`slim_system_prompt`** config knob — drops the ~10K-token inlined
+  tool prompt files + skills + subagents lists for local models that
+  pay 7-12 ms per prefill token. Verified on Gemma 4: takes
+  first-turn latency from 60-120 s to 10-20 s on the dead-silence cases.
+
+### Safety (advisory, never blocking — with one narrow exception)
+- Tool permission system (always/ask/never per tool)
+- Loop detection wired into `_handle_tool_response()` — injects an
+  advisory nudge when the same tool call repeats, never stops the
+  session
+- Three-tier escalating dedup on `write_file`:
+  1. First duplicate: friendly "move to next file"
+  2. Second duplicate: full directory listing + concrete next-action
+     suggestions
+  3. **Third duplicate: HARD BLOCK via `ToolError`** — narrow exception
+     to the no-blocking rule, only fires when file exists AND content
+     is identical AND it's the 3rd attempt. Never blocks legitimate
+     retries. After the block, `_prune_duplicate_writes()` removes the
+     older no-op write attempts from message history so the next turn
+     sees a cleaner context.
+- `_check_main_module_entry()` catches `__main__.py` files that import
+  `main` but never call it (the codec silent-exit bug)
+- `_check_missing_sibling_imports()` catches `from .x import Y` when
+  `x.py` doesn't exist on disk yet (the minivc unimportable-package bug)
+- `_truncate_old_tool_results()` proactively shrinks stale `read_file`
+  outputs in message history before each LLM call (idempotent;
+  keeps the last 6 in full)
+- API error auto-recovery (retry after 10s)
+- `auto_release.sh` and `watchdog.sh` cron jobs respect pause flags
+  at `.pause_auto_release` and `.pause_watchdog` for manual debugging
+
+## Install
+
+```bash
+pip install drydock-cli
+drydock --local http://localhost:8000/v1
+```
+
+For Gemma 4 / vLLM users, add this to `~/.drydock/config.toml` to drop
+the system prompt bloat:
+
+```toml
+slim_system_prompt = true
+```
+
+## Per-Project Instructions
+
+DryDock loads instructions from these files in the project root, in
+order:
+
+- **AGENTS.md** — Cross-tool standard (recommended). Same file works
+  with Claude Code, opencode, drydock, Aider, and other coding agents.
+- **DRYDOCK.md** — Legacy / drydock-only. Kept for backward compat;
+  prefer AGENTS.md for new projects.
+- **.drydock/rules/*.md** — Modular rules
+
+Auto-created if none exist. AGENTS.md is essential for devstral
+(it loops without one) but Gemma 4 works without it.
+
+## Recent fixes (April 2026)
+
+The user-pain debugging arc surfaced a string of issues that the old
+test harnesses couldn't catch. All committed in source and live in
+PyPI v2.6.25 (or queued for v2.6.26):
+
+- **Hard-block duplicate writes after 3 attempts** — narrow exception
+  to "no blocking" for pure no-op work. Verified: codec went from
+  FAIL (4× `__init__.py` loop, ignored STOP interrupt, broken --help)
+  → PASS (131 s, 10 writes, no loops, --help works).
+- **`slim_system_prompt`** — drops the inlined tool prompt files +
+  skills + subagents lists from the system prompt (~10K → ~3K tokens
+  for Gemma 4). Fixed the dead-silence-on-first-turn issue. Verified:
+  todo_list FAIL (0 messages in 121 s) → PASS (38 messages in 115 s).
+- **Trust dialog auto-dismissal in shakedown.py** — drydock pops a
+  blocking "Trust this folder?" modal on unfamiliar directories. The
+  harness now detects and answers it.
+- **PRD reset between runs** — the model edits PRD.md across sessions
+  (adds "✅ Completed" tables, chat-style filler). The harness restores
+  from `PRD.master.md` automatically, with the canary fixture at
+  `tests/fixtures/doc_qa_system_prd.md`.
+- **`_task_manager.py` rename** — TaskCreate/Update/List were a duplicate
+  task system that confused Gemma 4 into hanging. Underscore prefix
+  excludes them from tool discovery.
+- **`auto_release.sh` fail-loud on token errors** — the GitHub deploy
+  step was using `2>/dev/null` so an expired token silently skipped the
+  push. The remote was 287 commits behind for ~2 days before anyone
+  noticed.
+- **Loop detection wired up** — `_check_tool_call_repetition()` was
+  defined but never actually called from anywhere. Now fires from
+  `_handle_tool_response()` and injects an advisory nudge.
+- **`_truncate_old_tool_results()`** — proactive shrinkage of stale
+  `read_file` outputs to keep context small as sessions grow.
+
+## Roadmap
+
+### Near-term
+- Confirm 8-10/10 stable pass rate on the 10-project shakedown suite
+  with `slim_system_prompt` + hard block (variance run in progress)
+- Per-model `auto_compact_threshold` (current default of 200K is
+  higher than Gemma 4's 131K max context, so it never fires)
+- Streamline the system prompt further: drop the universal sections
+  that don't apply to local-model agents
+- Investigate why some test_projects PRDs pass on one run and loop on
+  the next — variance is the rule with Gemma 4
+
+### Medium-term
+- Per-model knobs: `slim_system_prompt`, `thinking`, tool exclusion
+  list, `auto_compact_threshold`
+- A second deployment target so PyPI failures don't lose history
+- Replace the old `tui_test.py` and `core_tests_real.sh` entirely;
+  shakedown.py is the only honest test
+- Token cost dashboard so first-turn prefill regressions are caught
+  before they hit users
+
+### Long-term
+- Support larger models as hardware improves
+- Plugin marketplace for custom tools/skills
+- Web dashboard for monitoring long runs
+- Multi-model routing (different models for different tasks)
+
+## Architecture Notes
+
+See [CLAUDE.md](CLAUDE.md) for technical details, file locations,
+constraints, lessons learned, and the development workflow including
+the `.pause_auto_release` / `.pause_watchdog` flags you'll want during
+manual debugging.
+
+## Legal
+
+All code is original or forked from Apache 2.0 mistral-vibe.
+Architecture improvements are standard design patterns implemented from
+scratch. No proprietary code copied.

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/drydock/core/agent_loop.py

@@ -483,16 +483,22 @@ class AgentLoop:
         # === AUTO-CONTEXT ===
         # Auto-explore project files + inject relevant skill for the task type.
         # The model handles everything with subagents (v2.0.0 fixed delegation).
+        _ar_t0 = time.perf_counter()
         await self._auto_route_task(user_msg)
+        _ar_t1 = time.perf_counter()
+        logger.warning("[TIMING] _auto_route_task: %.2fs", _ar_t1 - _ar_t0)
 
         try:
             should_break_loop = False
             tool_turns = 0
             api_error_count = 0
             has_made_edit = False  # Track if model has used search_replace/write_file
+            logger.warning("[TIMING] entering conversation while loop")
             while not should_break_loop:
                 # Loop protection: prevent infinite tool-call loops
                 tool_turns += 1
+                _wt0 = time.perf_counter()
+                logger.warning("[TIMING] turn %d: starting", tool_turns)
                 if tool_turns > MAX_TOOL_TURNS:
                     yield AssistantEvent(
                         content=f"\n\n[Maximum tool call limit ({MAX_TOOL_TURNS}) reached. Stopping.]\n",
@@ -508,9 +514,12 @@ class AgentLoop:
                         "stop and ask the user for clarification."
                     )
 
+                _mw0 = time.perf_counter()
                 result = await self.middleware_pipeline.run_before_turn(
                     self._get_context()
                 )
+                _mw1 = time.perf_counter()
+                logger.warning("[TIMING] turn %d: middleware=%.2fs action=%s", tool_turns, _mw1 - _mw0, result.action)
                 async for event in self._handle_middleware_result(result):
                     yield event
 
@@ -521,11 +530,13 @@ class AgentLoop:
                 user_cancelled = False
                 try:
                     force_stopped = False
+                    logger.warning("[TIMING] turn %d: calling _perform_llm_turn", tool_turns)
                     async for event in self._perform_llm_turn():
                         if is_user_cancellation_event(event):
                             user_cancelled = True
                         if isinstance(event, AssistantEvent) and event.stopped_by_middleware:
                             force_stopped = True
+                        logger.warning("[TIMING] turn %d: yielding event type=%s", tool_turns, type(event).__name__)
                         yield event
                         await self._save_messages()
                     if force_stopped:
@@ -1372,13 +1383,23 @@ class AgentLoop:
             self.messages.append(LLMMessage(role=Role.user, content="Continue."))
 
     async def _chat(self, max_tokens: int | None = None) -> LLMChunk:
+        _t0 = time.perf_counter()
         self._sanitize_message_ordering()
+        _t1 = time.perf_counter()
 
         active_model = self.config.get_active_model()
         provider = self.config.get_provider_for_model(active_model)
 
         available_tools = self.format_handler.get_available_tools(self.tool_manager)
         tool_choice = self.format_handler.get_tool_choice()
+        _t2 = time.perf_counter()
+
+        n_msgs = len(self.messages)
+        n_tools = len(available_tools) if available_tools else 0
+        logger.info(
+            "[TIMING] _chat start: sanitize=%.2fs prep=%.2fs msgs=%d tools=%d",
+            _t1 - _t0, _t2 - _t1, n_msgs, n_tools,
+        )
 
         try:
             start_time = time.perf_counter()
@@ -1398,6 +1419,12 @@ class AgentLoop:
             )
             end_time = time.perf_counter()
 
+            logger.info(
+                "[TIMING] backend.complete returned in %.2fs (prompt=%s completion=%s)",
+                end_time - start_time,
+                result.usage.prompt_tokens if result.usage else "?",
+                result.usage.completion_tokens if result.usage else "?",
+            )
             if result.usage is None:
                 raise AgentLoopLLMResponseError(
                     "Usage data missing in non-streaming completion response"

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/drydock/core/agents/models.py

@@ -43,6 +43,7 @@ class BuiltinAgentName(StrEnum):
     EXPLORE = "explore"
     DIAGNOSTIC = "diagnostic"
     PLANNER = "planner"
+    BUILDER = "builder"
 
 
 @dataclass(frozen=True)
@@ -223,6 +224,34 @@ PLANNER = AgentProfile(
     },
 )
 
+BUILDER = AgentProfile(
+    name=BuiltinAgentName.BUILDER,
+    display_name="Builder",
+    description=(
+        "Subagent that creates an entire Python package from a PRD. Use this "
+        "when the user gives you a PRD with 4+ files to write — delegating "
+        "keeps the main agent's context small and lets the builder iterate "
+        "in its own scratch space. Has read_file, write_file, search_replace, "
+        "glob, and bash. Returns a short summary listing the files created "
+        "and whether `python3 -m <pkg> --help` worked. Up to 40 turns."
+    ),
+    safety=AgentSafety.DESTRUCTIVE,
+    agent_type=AgentType.SUBAGENT,
+    max_turns=40,
+    overrides={
+        "enabled_tools": [
+            "read_file", "write_file", "search_replace",
+            "glob", "grep", "bash",
+        ],
+        "system_prompt_id": "builder",
+        "tools": {
+            "write_file": {"permission": "always"},
+            "search_replace": {"permission": "always"},
+            "bash": {"permission": "always"},
+        },
+    },
+)
+
 BUILTIN_AGENTS: dict[str, AgentProfile] = {
     BuiltinAgentName.DEFAULT: DEFAULT,
     BuiltinAgentName.PLAN: PLAN,
@@ -231,4 +260,5 @@ BUILTIN_AGENTS: dict[str, AgentProfile] = {
     BuiltinAgentName.EXPLORE: EXPLORE,
     BuiltinAgentName.DIAGNOSTIC: DIAGNOSTIC,
     BuiltinAgentName.PLANNER: PLANNER,
+    BuiltinAgentName.BUILDER: BUILDER,
 }

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/drydock/core/config/_settings.py

@@ -305,6 +305,14 @@ class VibeConfig(BaseSettings):
     include_model_info: bool = True
     include_project_context: bool = True
     include_prompt_detail: bool = True
+    # When True, the system prompt drops the inlined per-tool prompt files
+    # (~6500 tokens for the 24 builtin tools) AND the available skills /
+    # subagents listings. The model still receives the OpenAI tool function
+    # schemas via the `tools` field of the API call. Recommended for local
+    # models like Gemma 4 where every prefill token costs ~7-12 ms and the
+    # bloated default system prompt (~10K tokens) causes 60-120s first-turn
+    # latency. Defaults False for backward compatibility.
+    slim_system_prompt: bool = False
     enable_update_checks: bool = True
     enable_auto_update: bool = True
     enable_notifications: bool = True

drydock_cli-2.6.27/drydock/core/prompts/builder.md

@@ -0,0 +1,45 @@
+You are the Builder subagent. Your job is to build an entire Python package
+from a PRD with NO further input from the user.
+
+You have these tools and nothing else:
+  read_file, write_file, search_replace, glob, grep, bash
+
+Workflow
+
+1. Read PRD.md (or the spec file you were pointed at).
+2. Create EVERY file the PRD lists. Start with __init__.py and __main__.py,
+   then the modules they import from. Use write_file once per file with the
+   COMPLETE contents. Use ABSOLUTE imports: `from package_name.module import X`,
+   never relative imports.
+3. After writing all files, run `python3 -m <package_name> --help` once.
+4. If --help fails, read the traceback, identify the file/line, fix it with
+   search_replace, then re-run `--help`.
+5. If a subcommand from the PRD is mentioned, run it once to verify it works.
+6. STOP after the package executes cleanly. Do not test edge cases the PRD
+   does not require. Do not refactor.
+
+Hard rules
+
+- One write_file per file. Never write the same file twice unless you're
+  fixing a verified bug. The framework will hard-block a third identical
+  no-op write — if you see "BLOCKED:" in a tool result, write a different
+  file or run bash, never the same one again.
+- Every file you `import .X` from MUST be created. The framework will warn
+  you if `__init__.py` references a module that doesn't exist on disk.
+- `__main__.py` MUST actually CALL the entry function:
+      from package.cli import main
+      if __name__ == "__main__":
+          main()
+  Importing `main` without calling it produces a silent-exit package.
+- Never read a file you wrote yourself in this session — you already know
+  what's in it. Reading wastes context.
+- Never run `pytest` or write tests unless the PRD explicitly asks for tests.
+- Never `pip install` anything unless the PRD names a third-party dependency
+  AND you've verified it isn't already importable.
+
+Result
+
+When you stop, your final tool call should be a `bash` that ran
+`python3 -m <pkg> --help` and exited 0. The framework summarizes your run
+back to the main agent automatically — you do NOT need to write a summary
+yourself.

drydock_cli-2.6.27/drydock/core/prompts/gemma4.md

@@ -0,0 +1,64 @@
+You are DryDock, a CLI coding agent. You write code, fix bugs, and build projects.
+
+ACT IMMEDIATELY. Your FIRST response must be a tool call — not text. Do NOT explain, plan, or ask. Call a tool NOW.
+
+Your tools: read_file, write_file, search_replace, grep, glob, bash, task.
+
+DELEGATION (only for genuinely large tasks)
+
+For tasks that need you to write 6+ source files OR have subdirectories
+(e.g. "build the X package from PRD.md" with multiple subpackages),
+DELEGATE the build to a subagent so the main agent's context stays small.
+The Gemma 4 main loop slows down with bigger context — subagents work in
+their own scratch space.
+
+  task(agent="builder", task="Read PRD.md and build the entire <pkg> package. "
+                              "Write every file the PRD lists. Verify "
+                              "python3 -m <pkg> --help works. Stop when "
+                              "the package executes cleanly.")
+
+For codebase exploration on an existing repo:
+  task(agent="explore", task="Find where <function> is defined")
+
+For debugging a test failure or traceback:
+  task(agent="diagnostic", task="A bash command failed with this traceback: ... "
+                                "Find the bug and report the file:line.")
+
+For multi-module changes that need a plan first:
+  task(agent="planner", task="Plan the change: ...")
+
+DO NOT delegate trivial work. Most PRDs are small — build them directly.
+Rules of thumb:
+- 1-5 files, no subdirs → BUILD INLINE. Do not call task.
+- 6+ files OR subdirectories OR multiple subpackages → DELEGATE to builder.
+- Editing an existing file or fixing a known bug → BUILD INLINE.
+- "Where does function X live?" → DELEGATE to explore.
+
+When in doubt, build inline. A wasted delegation costs 60-90 seconds of
+extra context loading.
+
+Workflow for building from a PRD or spec (when NOT delegating):
+1. Read the spec file
+2. Create each file with write_file — start with __init__.py and __main__.py
+3. After all files, verify with bash: ls package_name/ to confirm all files exist
+4. Test with bash: python3 -m package_name --help
+5. Test each subcommand from the PRD to verify it works
+6. Fix any errors
+
+Workflow for fixing bugs:
+1. Grep for the function/class mentioned
+2. Read the source file
+3. Fix with search_replace
+4. Verify the fix
+
+Rules:
+- Create files immediately. Do not plan or discuss — write code.
+- Use absolute imports for Python packages
+- Always create __init__.py and __main__.py for packages
+- Keep responses under 50 words. Code speaks for itself.
+- NEVER ask "would you like me to proceed" or "shall I continue" — JUST DO IT.
+- After creating/editing a file, move to the next one. Do not stop.
+- Follow the EXACT CLI interface specified in the PRD. Match argument names, subcommands, and flags exactly.
+- Every subcommand in the PRD must have a working handler — not just argparse registration.
+- After creating files, run python3 -m package_name [subcommand] to verify each one works.
+- If a write_file result says "BLOCKED:" you've called it 3+ times with identical content. STOP that path. Write a DIFFERENT file or run bash. Never retry the blocked write.

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/drydock/core/system_prompt.py

@@ -258,20 +258,28 @@ def get_universal_system_prompt(
 
     if config.include_prompt_detail:
         static_sections.append(_get_os_system_prompt())
-        tool_prompts = []
-        for tool_class in tool_manager.available_tools.values():
-            if prompt := tool_class.get_tool_prompt():
-                tool_prompts.append(prompt)
-        if tool_prompts:
-            static_sections.append("\n---\n".join(tool_prompts))
-
-        skills_section = _get_available_skills_section(skill_manager)
-        if skills_section:
-            static_sections.append(skills_section)
-
-        subagents_section = _get_available_subagents_section(agent_manager)
-        if subagents_section:
-            static_sections.append(subagents_section)
+
+        # slim_system_prompt drops the heaviest static sections — tool
+        # prompt files, skills list, subagents list — that bloat the prompt
+        # to ~10K tokens for local models. The OpenAI tool function schemas
+        # still go to the model via the API `tools` field, so capability
+        # is preserved; only the inlined examples and best-practices docs
+        # are skipped.
+        if not getattr(config, "slim_system_prompt", False):
+            tool_prompts = []
+            for tool_class in tool_manager.available_tools.values():
+                if prompt := tool_class.get_tool_prompt():
+                    tool_prompts.append(prompt)
+            if tool_prompts:
+                static_sections.append("\n---\n".join(tool_prompts))
+
+            skills_section = _get_available_skills_section(skill_manager)
+            if skills_section:
+                static_sections.append(skills_section)
+
+            subagents_section = _get_available_subagents_section(agent_manager)
+            if subagents_section:
+                static_sections.append(subagents_section)
 
     # === DYNAMIC SECTIONS (change per project/directory) ===
     dynamic_sections = []

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/drydock/core/tools/builtins/task.py

@@ -51,8 +51,21 @@ class TaskResult(BaseModel):
 
 
 class TaskToolConfig(BaseToolConfig):
-    permission: ToolPermission = ToolPermission.ASK
-    allowlist: list[str] = Field(default=[BuiltinAgentName.EXPLORE, BuiltinAgentName.DIAGNOSTIC, BuiltinAgentName.PLANNER])
+    # ALWAYS instead of ASK because the subagent is itself sandboxed by
+    # its own per-tool permissions (see e.g. BUILDER's overrides). Asking
+    # the user to approve every delegation defeats the purpose of subagents
+    # — the model can't iterate without blocking on a TUI dialog the
+    # automated harness can't dismiss. Per-subagent profiles are the right
+    # place to control which tools they're allowed to call.
+    permission: ToolPermission = ToolPermission.ALWAYS
+    allowlist: list[str] = Field(
+        default=[
+            BuiltinAgentName.EXPLORE,
+            BuiltinAgentName.DIAGNOSTIC,
+            BuiltinAgentName.PLANNER,
+            BuiltinAgentName.BUILDER,
+        ]
+    )
 
 
 class Task(

{drydock_cli-2.6.25 → drydock_cli-2.6.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.6.25"
+version = "2.6.27"
 description = "Drydock — nautical CLI coding agent"
 readme = "README.md"
 requires-python = ">=3.12"