drydock-cli 2.7.9__tar.gz → 2.7.15__tar.gz

drydock_cli-2.7.15/.auto_release.lock

@@ -0,0 +1 @@
+166653

drydock_cli-2.7.15/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"facd51cc-fa47-4911-afc8-14485ae9caf3","pid":711220,"acquiredAt":1775966390914}

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.9
+Version: 2.7.15
 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

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/drydock/admiral/detectors_proposed.py

@@ -43,11 +43,18 @@ def _tool_result_errored(m: LLMMessage) -> bool:
     """Heuristic: does this tool-role message look like a failure?
 
     Conservative — we only want high-precision firing on actual errors.
-    Scanned the first 800 chars of the result content.
+    Scanned the first 200 chars of the result content (tightened from 800
+    to avoid false positives when matched file content contains words like
+    "error" or "failed" — grep results starting with "matches:" are always
+    successful).
     """
     if m.role is not Role.tool:
         return False
-    content = str(getattr(m, "content", "") or "")[:800].lower()
+    raw = str(getattr(m, "content", "") or "")
+    # Successful grep results start with "matches:" — never treat as error.
+    if raw.lstrip().startswith("matches:"):
+        return False
+    content = raw[:200].lower()
     return any(marker in content for marker in _TOOL_ERROR_MARKERS)
 
 

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/drydock/core/agent_loop.py

@@ -1703,10 +1703,10 @@ class AgentLoop:
         Runs every turn but is a no-op when nothing exceeds the caps.
         Truncation is in-place and idempotent.
         """
-        KEEP_RECENT = 6              # last N tool messages stay full
-        SOFT_CAP_BYTES = 800         # tool result longer than this gets shrunk
-        HEAD_BYTES = 400             # bytes kept from the head
-        TAIL_BYTES = 100             # bytes kept from the tail
+        KEEP_RECENT = 4              # last N tool messages stay full
+        SOFT_CAP_BYTES = 500         # tool result longer than this gets shrunk
+        HEAD_BYTES = 200             # bytes kept from the head
+        TAIL_BYTES = 60              # bytes kept from the tail
 
         if len(self.messages) < KEEP_RECENT + 4:
             return
@@ -2334,7 +2334,16 @@ class AgentLoop:
                 if replace_last_tool:
                     msg.content = f"[SYSTEM: {text}]"
                 else:
-                    msg.content = (msg.content or "") + f"\n\n[SYSTEM: {text}]"
+                    content = msg.content or ""
+                    # Cap at 2 accumulated system notes per message; replace the
+                    # last one when the limit is exceeded so repeated admiral
+                    # interventions don't unboundedly bloat the context.
+                    _SYS_PREFIX = "\n\n[SYSTEM: "
+                    if content.count(_SYS_PREFIX) >= 2:
+                        last_idx = content.rfind(_SYS_PREFIX)
+                        msg.content = content[:last_idx] + _SYS_PREFIX + text + "]"
+                    else:
+                        msg.content = content + _SYS_PREFIX + text + "]"
                 return
 
         # Second try: append to last user message

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/drydock/core/llm/format.py

@@ -367,6 +367,32 @@ class APIToolFormatHandler:
                 continue
 
             args_model, _ = tool_class._get_tool_args_results()
+
+            # Detect when model copied truncated-history args (our truncation
+            # code replaces large tool-call args with {_truncated, _original_bytes,
+            # path}).  Return a clear advisory instead of a pydantic traceback so
+            # the model re-does the call with real arguments rather than retrying
+            # the truncated form.
+            if (isinstance(parsed_call.raw_args, dict)
+                    and parsed_call.raw_args.get("_truncated")):
+                path_hint = (parsed_call.raw_args.get("path")
+                             or parsed_call.raw_args.get("file_path")
+                             or "")
+                hint = f" Re-read `{path_hint}` with read_file first." if path_hint else ""
+                failed_calls.append(
+                    FailedToolCall(
+                        tool_name=parsed_call.tool_name,
+                        call_id=parsed_call.call_id,
+                        error=(
+                            f"{parsed_call.tool_name}: your call used a "
+                            f"truncated history entry as a template (it contained "
+                            f"'_truncated'/'_original_bytes' instead of real "
+                            f"arguments).{hint} Provide the full required arguments."
+                        ),
+                    )
+                )
+                continue
+
             try:
                 validated_args = args_model.model_validate(parsed_call.raw_args)
                 resolved_calls.append(

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/drydock/core/tools/builtins/bash.py

@@ -404,13 +404,27 @@ class Bash(
         self, *, command: str, stdout: str, stderr: str, returncode: int
     ) -> BashResult:
         if returncode != 0:
-            error_msg = f"Command failed: {command!r}\n"
-            error_msg += f"Return code: {returncode}"
-            if stderr:
-                error_msg += f"\nStderr: {stderr}"
-            if stdout:
-                error_msg += f"\nStdout: {stdout}"
-            raise ToolError(error_msg.strip())
+            # ADVISORY ONLY — never raise ToolError for non-zero exit codes.
+            # Raising blocks the model: it gets <tool_error> with no useful
+            # output, doesn't know if exit 1 means "no matches" (grep) or a
+            # real failure, and retries identically.  Same pattern as the
+            # timeout handler above.  Include a clear exit-code annotation so
+            # the model can reason about what happened.
+            # See feedback_no_tool_errors_for_loop_detection.md.
+            annotation = f"[Exit code {returncode}]"
+            if not stdout and not stderr:
+                annotation += " (no output)"
+                if returncode == 1:
+                    annotation += (
+                        " — for grep/find, exit code 1 means no matches found"
+                    )
+            annotated_stdout = (stdout + "\n" + annotation).strip() if stdout else annotation
+            return BashResult(
+                command=command,
+                stdout=annotated_stdout,
+                stderr=stderr,
+                returncode=returncode,
+            )
 
         return BashResult(
             command=command, stdout=stdout, stderr=stderr, returncode=returncode
@@ -445,7 +459,39 @@ class Bash(
                 )
             except TimeoutError:
                 await _kill_process_tree(proc)
-                raise self._build_timeout_error(args.command, timeout)
+                # ADVISORY ONLY — never raise ToolError on timeout; raising
+                # causes the model to retry the exact same command (loop).
+                # Track repeat timeouts per command and escalate the hint.
+                # See feedback_no_tool_errors_for_loop_detection.md.
+                timeout_state = self.state.__dict__.setdefault(
+                    "_bash_timeout_history", {}
+                )
+                count = timeout_state.get(args.command, 0) + 1
+                timeout_state[args.command] = count
+                if count == 1:
+                    hint = (
+                        "The command was killed. If it starts a server or "
+                        "long-running process, background it with `command &` "
+                        "instead of running it in the foreground."
+                    )
+                else:
+                    hint = (
+                        f"[TIMEOUT #{count}] You have timed out {count}x on "
+                        f"this exact command. Running it again will produce the "
+                        f"same result. STOP retrying. Background servers with "
+                        f"`&`, check existing listeners with `ss -tlnp`, or fix "
+                        f"the underlying cause before re-running."
+                    )
+                yield BashResult(
+                    command=args.command,
+                    stdout=(
+                        f"Command timed out after {timeout}s: {args.command!r}\n"
+                        f"{hint}"
+                    ),
+                    stderr="",
+                    returncode=124,
+                )
+                return
 
             encoding = _get_subprocess_encoding()
             stdout = (

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/drydock/core/tools/builtins/read_file.py

@@ -237,12 +237,45 @@ class ReadFile(
                 f"Security error: Cannot read path '{file_path}' outside of the project directory '{Path.cwd()}'."
             )
         except FileNotFoundError:
-            raise ToolError(f"File not found at: {file_path}")
+            raise ToolError(self._not_found_msg(file_path))
 
         if not resolved_path.exists():
-            raise ToolError(f"File not found at: {file_path}")
+            raise ToolError(self._not_found_msg(file_path))
         if resolved_path.is_dir():
-            raise ToolError(f"Path is a directory, not a file: {file_path}")
+            raise ToolError(self._is_dir_msg(file_path, resolved_path))
+
+    @staticmethod
+    def _not_found_msg(file_path: Path) -> str:
+        """Return 'File not found' error with parent directory listing for context."""
+        parent = file_path.parent if file_path.parent != file_path else Path(".")
+        try:
+            entries = sorted(p.name for p in parent.iterdir())
+            if entries:
+                listing = "\n".join(f"  {e}" for e in entries[:30])
+                suffix = f"\n  ... ({len(entries) - 30} more)" if len(entries) > 30 else ""
+                return (
+                    f"File not found at: {file_path}\n"
+                    f"Contents of {parent}/:\n{listing}{suffix}"
+                )
+        except (PermissionError, OSError):
+            pass
+        return f"File not found at: {file_path}"
+
+    @staticmethod
+    def _is_dir_msg(file_path: Path, resolved_path: Path) -> str:
+        """Return 'is a directory' error with directory listing so model can pick a file."""
+        try:
+            entries = sorted(p.name for p in resolved_path.iterdir())
+            if entries:
+                listing = "\n".join(f"  {e}" for e in entries[:30])
+                suffix = f"\n  ... ({len(entries) - 30} more)" if len(entries) > 30 else ""
+                return (
+                    f"Path is a directory, not a file: {file_path}\n"
+                    f"Contents of {file_path}/:\n{listing}{suffix}"
+                )
+        except (PermissionError, OSError):
+            pass
+        return f"Path is a directory, not a file: {file_path}"
 
     @classmethod
     def format_call_display(cls, args: ReadFileArgs) -> ToolCallDisplay:

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/drydock/core/tools/builtins/search_replace.py

@@ -97,6 +97,12 @@ class SearchReplace(
     @classmethod
     def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
         if isinstance(event.result, SearchReplaceResult):
+            if event.result.blocks_applied == 0:
+                return ToolResultDisplay(
+                    success=False,
+                    message=event.result.content[:120].split("\n")[0],
+                    warnings=event.result.warnings,
+                )
             return ToolResultDisplay(
                 success=True,
                 message=f"Applied {event.result.blocks_applied} block{'' if event.result.blocks_applied == 1 else 's'}",
@@ -218,30 +224,42 @@ class SearchReplace(
                                     f"\n-----FILE TAIL (last 800 chars)-----\n{tail}\n"
                                     if tail else ""
                                 )
-                                raise ToolError(
-                                    f"{base_msg}\n\n[LOOP-BREAKER: this is the "
-                                    f"#{refused_entry['count']} consecutive REFUSED on "
-                                    f"{target.name}. Stop sending the same raw content. "
-                                    f"Actual file content (first 1500 chars of "
-                                    f"{existing_size} bytes):\n"
-                                    f"-----FILE HEAD-----\n{head}\n-----FILE END HEAD-----"
-                                    f"{tail_block}\n"
-                                    f"Choose ONE: (a) call write_file with overwrite=True "
-                                    f"to replace the whole file with your raw content, OR "
-                                    f"(b) send a proper SEARCH/REPLACE block anchored on "
-                                    f"text from the file head/tail above.]"
+                                yield SearchReplaceResult(
+                                    file=str(target),
+                                    blocks_applied=0,
+                                    lines_changed=0,
+                                    content=(
+                                        f"{base_msg}\n\n[LOOP-BREAKER: this is the "
+                                        f"#{refused_entry['count']} consecutive REFUSED on "
+                                        f"{target.name}. Stop sending the same raw content. "
+                                        f"Actual file content (first 1500 chars of "
+                                        f"{existing_size} bytes):\n"
+                                        f"-----FILE HEAD-----\n{head}\n-----FILE END HEAD-----"
+                                        f"{tail_block}\n"
+                                        f"Choose ONE: (a) call write_file with overwrite=True "
+                                        f"to replace the whole file with your raw content, OR "
+                                        f"(b) send a proper SEARCH/REPLACE block anchored on "
+                                        f"text from the file head/tail above.]"
+                                    ),
                                 )
-                            raise ToolError(
-                                f"{base_msg} To add new code, use a SEARCH/REPLACE "
-                                f"block anchored on the last line of the file:\n"
-                                f"<<<<<<< SEARCH\n"
-                                f"[the file's actual final line, copied exactly]\n"
-                                f"=======\n"
-                                f"[the same final line]\n\n"
-                                f"[your new code]\n"
-                                f">>>>>>> REPLACE\n"
-                                f"If you intended a full rewrite, use write_file instead."
+                                return
+                            yield SearchReplaceResult(
+                                file=str(target),
+                                blocks_applied=0,
+                                lines_changed=0,
+                                content=(
+                                    f"{base_msg} To add new code, use a SEARCH/REPLACE "
+                                    f"block anchored on the last line of the file:\n"
+                                    f"<<<<<<< SEARCH\n"
+                                    f"[the file's actual final line, copied exactly]\n"
+                                    f"=======\n"
+                                    f"[the same final line]\n\n"
+                                    f"[your new code]\n"
+                                    f">>>>>>> REPLACE\n"
+                                    f"If you intended a full rewrite, use write_file instead."
+                                ),
                             )
+                            return
                         _log.getLogger(__name__).info(
                             "search_replace: no blocks — overwriting %s", target,
                         )
@@ -380,21 +398,46 @@ class SearchReplace(
                 except Exception:
                     pass
 
-            raise ToolError(error_message)
-        else:
-            # Success → reset the fail counter for this file
-            state = self.state.__dict__.setdefault("_sr_fail_history", {})
-            state.pop(str(file_path), None)
-            refused_state = self.state.__dict__.setdefault(
-                "_sr_refused_raw_history", {}
+            # Return advisory result instead of raising ToolError.
+            # Hard ToolError blocks cause their own retry loops on longer tasks
+            # (model panics and re-calls the same failing search_replace). The
+            # advisory result delivers the same guidance message + file head
+            # without triggering the panic-retry pattern.
+            yield SearchReplaceResult(
+                file=str(file_path),
+                blocks_applied=0,
+                lines_changed=0,
+                content=error_message,
             )
-            refused_state.pop(str(file_path), None)
+            return
+        # Success → reset the fail counter for this file
+        state = self.state.__dict__.setdefault("_sr_fail_history", {})
+        state.pop(str(file_path), None)
+        refused_state = self.state.__dict__.setdefault(
+            "_sr_refused_raw_history", {}
+        )
+        refused_state.pop(str(file_path), None)
 
         modified_content = block_result.content
 
         # Calculate line changes
         if modified_content == original_content:
             lines_changed = 0
+            # The SEARCH text was found and the REPLACE was identical — nothing
+            # actually changed. Tell the model clearly so it doesn't retry.
+            yield SearchReplaceResult(
+                file=str(file_path),
+                blocks_applied=block_result.applied,
+                lines_changed=0,
+                warnings=block_result.warnings,
+                content=(
+                    f"{file_path.name}: ALREADY CORRECT — the search text was found "
+                    f"but the replacement is identical to the current content. "
+                    f"No change was written. The file already has the desired state. "
+                    f"Move on to the next task."
+                ),
+            )
+            return
         else:
             original_lines = len(original_content.splitlines())
             new_lines = len(modified_content.splitlines())
@@ -511,7 +554,16 @@ class SearchReplace(
             )
 
         if not content:
-            raise ToolError("Empty content provided")
+            raise ToolError(
+                "Empty content provided. You must include SEARCH/REPLACE blocks.\n"
+                "Format:\n"
+                "<<<<<<< SEARCH\n"
+                "exact text to find\n"
+                "=======\n"
+                "replacement text\n"
+                ">>>>>>> REPLACE\n"
+                "If you want to create a new file instead, use write_file."
+            )
 
         project_root = Path.cwd()
         file_path = Path(file_path_str).expanduser()

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/drydock/core/tools/builtins/write_file.py

@@ -483,6 +483,23 @@ class WriteFile(
                                 f"from your plan, or run `bash` with `python3 -m "
                                 f"{file_path.parent.name} --help` to verify."
                             )
+                            # Also surface missing imports so the model knows
+                            # which file to write next instead of re-looping.
+                            if file_path.suffix == ".py":
+                                try:
+                                    import ast as _ast
+                                    _tree = _ast.parse(args.content)
+                                    missing = _check_missing_sibling_imports(
+                                        _tree, file_path
+                                    )
+                                    if missing:
+                                        body += (
+                                            f" This file imports modules that don't "
+                                            f"exist yet: {sorted(missing)}. "
+                                            f"Write those files next."
+                                        )
+                                except Exception:
+                                    pass
                         except Exception:
                             body += "Move to the NEXT file in your plan."
                     else:

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.9"
+version = "2.7.15"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/resume.md

@@ -25,7 +25,17 @@
    - `feedback_local_proposer_only.md` — proposer must default to local vLLM,
      never silently phone home
 
-## Where things stand (snapshot at 2026-04-25 ~20:30 UTC)
+## Where things stand (snapshot at 2026-04-27 ~02:10 UTC)
+
+**USER IS ON A TRIP 2026-04-26 → 2026-05-01.**
+The autonomous review loop (`/data3/drydock/scripts/autonomous_review.sh`)
+runs every 30 min via cron and continues this work without human input.
+Pause via `touch /data3/drydock/.pause_autonomous_loop`.
+Disable via `crontab -l | grep -v autonomous_review | crontab -`.
+Trip log: `/data3/drydock/trip_log.md`.
+Autonomous run log: `/data3/drydock/logs/autonomous_review.log`.
+
+
 
 ### Wins this session
 | What | Result |

{drydock_cli-2.7.9 → drydock_cli-2.7.15}/scripts/auto_release.sh

@@ -85,8 +85,16 @@ rm -rf dist/
 $PYTHON -m build 2>/dev/null
 
 # Publish to PyPI
+# PYTHONNOUSERSITE=1 avoids a jaraco.functools circular-import that occurs
+# when ~/.local/lib/python3.12/site-packages/setuptools conflicts with the
+# miniconda3 vendored copy; set +e so a twine failure doesn't kill the
+# script before the local-wheel fallback can run.
 PYPI_TOKEN=$(cat ~/.config/drydock/pypi_token)
-$PYTHON -m twine upload dist/drydock_cli-${NEW_VERSION}* -u __token__ -p "$PYPI_TOKEN" 2>/dev/null
+set +e
+TWINE_OUT=$(PYTHONNOUSERSITE=1 $PYTHON -m twine upload dist/drydock_cli-${NEW_VERSION}* -u __token__ -p "$PYPI_TOKEN" 2>&1)
+TWINE_EXIT=$?
+set -e
+echo "[$(date)] twine exit=$TWINE_EXIT: $TWINE_OUT" >> "$DRYDOCK/logs/auto_release.log"
 
 # Deploy to GitHub — NOT silent. If the token is invalid this should scream.
 TMPDIR=$(mktemp -d)
@@ -126,11 +134,23 @@ else
 fi
 cd "$DRYDOCK"
 
-# Install on user's env (retry PyPI propagation)
-for i in 1 2 3; do
-    sleep 60
-    /home/bobef/miniforge3/envs/drydock/bin/pip install --force-reinstall --no-deps --no-cache-dir "drydock-cli==$NEW_VERSION" 2>/dev/null && break
-done
+# Install on user's env — try PyPI first, fall back to local wheel
+INSTALLED=0
+if [ $TWINE_EXIT -eq 0 ]; then
+    for i in 1 2 3; do
+        sleep 60
+        /home/bobef/miniforge3/envs/drydock/bin/pip install --force-reinstall --no-deps --no-cache-dir "drydock-cli==$NEW_VERSION" 2>/dev/null && INSTALLED=1 && break
+    done
+fi
+if [ $INSTALLED -eq 0 ]; then
+    # PyPI upload failed or propagation timed out — install from local wheel
+    LOCAL_WHEEL="$DRYDOCK/dist/drydock_cli-${NEW_VERSION}-py3-none-any.whl"
+    if [ -f "$LOCAL_WHEEL" ]; then
+        /home/bobef/miniforge3/envs/drydock/bin/pip install --force-reinstall --no-deps "$LOCAL_WHEEL" 2>/dev/null \
+            && echo "[$(date)] Installed v$NEW_VERSION from local wheel (PyPI upload failed)" >> "$DRYDOCK/logs/auto_release.log" \
+            || echo "[$(date)] ERROR: local wheel install also failed for v$NEW_VERSION" >> "$DRYDOCK/logs/auto_release.log"
+    fi
+fi
 
 # Tag
 git tag "v$NEW_VERSION" 2>/dev/null || true

drydock_cli-2.7.15/scripts/autonomous_review.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+# autonomous_review.sh — cron-launched Claude Code wrapper that continues the
+# drydock improvement loop while the user is on a trip.
+#
+# Designed to be called from cron:
+#   */30 * * * * /data3/drydock/scripts/autonomous_review.sh
+#
+# Behavior:
+#   - Pause sentinel: /data3/drydock/.pause_autonomous_loop → exit silently
+#   - flock prevents overlapping runs (if previous claude is still working)
+#   - Hard timeout via `timeout` command (15 min cap)
+#   - Per-run cost cap via --max-budget-usd
+#   - All output appended to /data3/drydock/logs/autonomous_review.log
+#   - Trip log at /data3/drydock/trip_log.md is the human-readable summary
+
+set -u
+
+DRYDOCK=/data3/drydock
+PAUSE_FILE="$DRYDOCK/.pause_autonomous_loop"
+LOG_DIR="$DRYDOCK/logs"
+RUN_LOG="$LOG_DIR/autonomous_review.log"
+TRIP_LOG="$DRYDOCK/trip_log.md"
+LOCK_FILE=/tmp/autonomous_review.lock
+PROMPT_FILE="$DRYDOCK/scripts/autonomous_review_prompt.md"
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+mkdir -p "$LOG_DIR"
+
+# --- Pause check ---
+if [ -f "$PAUSE_FILE" ]; then
+    echo "$NOW PAUSED via $PAUSE_FILE — exiting" >> "$RUN_LOG"
+    exit 0
+fi
+
+# --- Lock to prevent overlapping runs ---
+exec 9> "$LOCK_FILE"
+if ! flock -n 9; then
+    echo "$NOW SKIP — previous run still active" >> "$RUN_LOG"
+    exit 0
+fi
+
+# --- Pre-flight: ensure drydock directory exists and is git-clean enough ---
+cd "$DRYDOCK" || { echo "$NOW FATAL — cannot cd $DRYDOCK" >> "$RUN_LOG"; exit 1; }
+
+# --- Build the prompt argument ---
+if [ ! -f "$PROMPT_FILE" ]; then
+    echo "$NOW FATAL — prompt file missing: $PROMPT_FILE" >> "$RUN_LOG"
+    exit 1
+fi
+
+# --- Run claude with safety rails ---
+# - timeout 15m: hard kill if Claude runs too long
+# - --print: non-interactive, exits when done
+# - --dangerously-skip-permissions: required for cron (no human to approve)
+# - --max-budget-usd 0.50: cost cap per run
+# - --model sonnet: faster + cheaper than opus, plenty for status review + small fixes
+# - --effort medium: balance of quality vs speed
+# - --no-session-persistence: don't pollute session history
+# - --output-format text: human-readable for the run log
+# - --add-dir: explicit allow for the drydock tree
+
+echo "" >> "$RUN_LOG"
+echo "================ $NOW START ================" >> "$RUN_LOG"
+
+PROMPT_TEXT=$(cat "$PROMPT_FILE")
+
+PATH=/home/bobef/.local/bin:/home/bobef/miniconda3/bin:$PATH
+export PATH
+
+timeout --signal=TERM --kill-after=30s 15m \
+    claude \
+        --print \
+        --dangerously-skip-permissions \
+        --max-budget-usd 1.00 \
+        --model sonnet \
+        --effort medium \
+        --no-session-persistence \
+        --output-format text \
+        --add-dir "$DRYDOCK" \
+        --append-system-prompt "You are a cron-launched assistant. Be concise. Follow the rules in the user's prompt strictly. Default to writing a status line in trip_log.md rather than making speculative changes." \
+        "$PROMPT_TEXT" \
+    >> "$RUN_LOG" 2>&1
+
+EXIT_CODE=$?
+END_NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+echo "" >> "$RUN_LOG"
+echo "================ $END_NOW END exit=$EXIT_CODE ================" >> "$RUN_LOG"
+
+# --- Telegram notify on bad exit (timeout, crash) ---
+NOTIFY="$DRYDOCK/scripts/notify_release.py"
+if [ "$EXIT_CODE" != "0" ] && [ -f "$NOTIFY" ]; then
+    /home/bobef/miniconda3/bin/python3 "$NOTIFY" status \
+        "[autonomous_review] non-zero exit: $EXIT_CODE at $END_NOW (timeout=124, oom=137)" \
+        >/dev/null 2>&1 || true
+fi
+
+exit 0