drydock-cli 3.0.114__tar.gz → 3.0.116__tar.gz

{drydock_cli-3.0.114/drydock_cli.egg-info → drydock_cli-3.0.116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.114
+Version: 3.0.116
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.114 → drydock_cli-3.0.116}/drydock/agent.py

@@ -33,7 +33,7 @@ def _plan_has_unfinished(config: dict) -> bool:
     todo = config.get("_todo")
     return bool(todo) and any(status != "done" for _, status in todo)
 
-from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry
+from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry, RepetitionDetected
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
 
@@ -114,6 +114,16 @@ def run(
     """
     state.messages.append({"role": "user", "content": user_message})
 
+    # Recipe retrieval: give the model the TECHNIQUE this task needs (forensics,
+    # git-history rewrite, numpy-2.0 fix, cert gen, …) by appending the relevant
+    # bundled recipes to the system prompt. Keyword-matched, so only fitting ones
+    # are added; none matched = no change. Gated by config `recipes`.
+    if config.get("recipes", True):
+        from drydock.recipes import recipe_context
+        extra = recipe_context(user_message)
+        if extra:
+            system_prompt = system_prompt + extra
+
     max_turns = config.get("max_turns", 200)
     max_tool_calls = config.get("max_tool_calls", 0)  # 0 = unlimited
     # When set (sub-agents pass this), the model is offered ONLY these tools and
@@ -194,24 +204,28 @@ def run(
                     elif isinstance(event, AssistantTurn):
                         assistant_turn = event
                 break  # success
-            except StallRetry:
-                # The call stalled or over-thought past stall_retry_secs. First
-                # retry re-issues as-is (handles a transient server hang cheaply);
-                # if it KEEPS happening it's over-thinking, so escalate to decisive
-                # mode — a forcing suffix + a hard token cap that make a long
-                # reasoning turn impossible. Bounded; on exhaustion end cleanly.
+            except StallRetry as _sr:
+                # Stalled/over-thought past stall_retry_secs (wall-time), OR collapsed
+                # into a pure-repetition loop (RepetitionDetected, content-based). A
+                # first wall-time retry re-issues as-is (a transient hang clears); a
+                # persistent stall OR any repetition loop goes straight to decisive
+                # mode — a forcing suffix + hard token cap that make a long reasoning
+                # turn impossible. Repetition escalates immediately (re-issuing a loop
+                # just loops again). Bounded; on exhaustion end cleanly.
+                is_rep = isinstance(_sr, RepetitionDetected)
                 stall_retries += 1
                 if stall_retries > 3:
-                    yield TextChunk("\n[model kept stalling/over-thinking — giving up on this step.]\n")
+                    yield TextChunk("\n[model kept stalling/looping — giving up on this step.]\n")
                     assistant_turn = None
                     break
-                if stall_retries >= 2 and not decisive:
+                if (is_rep or stall_retries >= 2) and not decisive:
                     decisive = True
                     turn_config = dict(turn_config)
                     cur = int(turn_config.get("max_tokens", 8192) or 8192)
                     turn_config["max_tokens"] = min(cur, _DECISIVE_MAX_TOKENS)
                     turn_config["reasoning_effort"] = "low"
-                    yield TextChunk("\n[taking too long — forcing a decisive, single-action step...]\n")
+                    why = "output looping" if is_rep else "taking too long"
+                    yield TextChunk(f"\n[{why} — forcing a decisive, single-action step...]\n")
                 else:
                     yield TextChunk("\n[model server stalled — retrying...]\n")
                 continue

{drydock_cli-3.0.114 → drydock_cli-3.0.116}/drydock/config.py

@@ -39,6 +39,11 @@ DEFAULTS: dict[str, object] = {
     # generation usually isn't stalled — a known gemma/llama.cpp hang). 0 = off.
     # Set to e.g. 600 on a stall-prone local server. Bounded to a few retries.
     "stall_retry_secs": 0,
+    # Inject bundled technique recipes (drydock/recipes.py) relevant to the task
+    # into the system prompt, so a local model has the *method* a task needs
+    # instead of guessing. Retrieval is keyword-overlap; only relevant recipes are
+    # added (none = nothing injected). Set false to disable.
+    "recipes": True,
     "theme": "harbor",
     # Optional SECOND model ("advisor") for a stronger second opinion — e.g. a
     # Gemini OpenAI-compatible endpoint on another box. Empty = disabled. The

{drydock_cli-3.0.114 → drydock_cli-3.0.116}/drydock/providers.py

@@ -30,6 +30,14 @@ class StallRetry(Exception):
     abandons the wedged request and re-issues it; a fresh generation usually
     doesn't stall. Opt-in via config `stall_retry_secs` (0 = off)."""
 
+
+class RepetitionDetected(StallRetry):
+    """CONTENT trigger for the over-think interrupt: the model collapsed into a
+    pure-repetition loop (same short unit ×6+, 600+ chars) and produced no usable
+    action. Unlike the wall-time StallRetry this fires on the *content*, so it
+    never trips on productive-but-long reasoning — only genuine spinning. A plain
+    re-issue would just loop again, so the agent goes straight to decisive mode."""
+
 from drydock.loop_detect import runaway_repetition_len
 from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
@@ -540,6 +548,11 @@ def stream(
                     _rep_checked_at = len(text)
                     run = runaway_repetition_len(text)
                     if run:
+                        # With the over-think interrupt on, a genuine loop escalates
+                        # to a decisive retry (recover) instead of returning a
+                        # truncated turn. Otherwise keep the advisory trim+stop.
+                        if stall_secs:
+                            raise RepetitionDetected(0)
                         text = (
                             text[: len(text) - run]
                             + "\n[… output began repeating — stopped by drydock]"
@@ -599,10 +612,6 @@ def _complete_nonstreaming(
     # the generic special-token pass would eat the tool_call markers.
     text, had_leak = strip_leaked_tool_calls(msg.content or "")
     thinking, text = extract_thinking(text)
-    if thinking:
-        yield ReasoningChunk(thinking)
-    if text.strip():
-        yield TextChunk(text)
 
     tool_calls = []
     for i, tc in enumerate(getattr(msg, "tool_calls", None) or []):
@@ -613,6 +622,21 @@ def _complete_nonstreaming(
             "input": inp,
         })
 
+    # Repetition trigger for the over-think interrupt (gated by the same
+    # stall_secs feature). Non-streaming gemma turns are where the over-think
+    # lives; if the turn collapsed into a pure loop and produced NO usable action,
+    # go decisive rather than feeding the garbage turn into the conversation. Only
+    # fires on genuine repetition, so productive-but-long reasoning is never hit.
+    if stall_secs and not tool_calls and (
+        runaway_repetition_len(thinking or "") or runaway_repetition_len(text or "")
+    ):
+        raise RepetitionDetected(0)
+
+    if thinking:
+        yield ReasoningChunk(thinking)
+    if text.strip():
+        yield TextChunk(text)
+
     usage = getattr(resp, "usage", None)
     in_tok = usage.prompt_tokens if usage else 0
     out_tok = usage.completion_tokens if usage else 0

drydock_cli-3.0.116/drydock/recipes.py

@@ -0,0 +1,166 @@
+"""Bundled technique recipes — compact "how to do X" references retrieved by task
+text and injected into context, so a fixed local model has the *technique* a task
+needs instead of guessing. Retrieval is keyword-overlap (stdlib, no embeddings):
+cheap, deterministic, and good enough for a small curated set.
+
+All content original to Drydock. Gated by config `recipes` (default on).
+"""
+from __future__ import annotations
+
+import re
+
+# (title, keywords, body). Keep bodies tight and COMMAND-first — the model needs
+# the move, not an essay. Grounded in tbench failure categories we observed.
+RECIPES: list[tuple[str, list[str], str]] = [
+    ("Recover deleted / hidden / fragmented data from files",
+     ["recover", "deleted", "forensic", "forensics", "password", "strings", "binary",
+      "carve", "fragment", "hidden", "launchcode", "undelete", "disk", "raw"],
+     "Deleted or embedded content often still sits in a file/blob as raw bytes.\n"
+     "1. Search binary-safe for the pattern across everything:\n"
+     "   grep -aroE 'PATTERN' /path   (grep -a treats binary as text)\n"
+     "2. Pull printable strings and grep them — the target may be split across a\n"
+     "   non-printable byte, so `strings` shows it on TWO adjacent lines:\n"
+     "   strings BIGFILE | grep -A1 'MARKER'\n"
+     "   Then CONCATENATE the fragments (strip the break) to rebuild the value.\n"
+     "3. Inspect bytes to understand structure: xxd FILE | less  (or od -A x -t x1z).\n"
+     "If a value has a known shape (e.g. 23 chars, starts 8XD ends W54), build the\n"
+     "exact ERE: 8XD[A-Z0-9]{17}W54 — count the middle length precisely."),
+
+    ("Remove a secret / file from ALL git history",
+     ["git", "history", "secret", "sanitize", "remove", "rewrite", "filter", "purge",
+      "credential", "commit", "bfg", "filter-branch", "filter-repo"],
+     "Deleting a file in a new commit does NOT remove it from history. Rewrite it:\n"
+     "  git filter-repo --path SECRET --invert-paths      # preferred if installed\n"
+     "  git filter-repo --replace-text <(echo 'SECRET==>REDACTED')\n"
+     "If filter-repo is absent, use the built-in (slower):\n"
+     "  git filter-branch --force --index-filter \\\n"
+     "    'git rm --cached --ignore-unmatch PATH' --prune-empty --tag-name-filter cat -- --all\n"
+     "Then: rm -rf .git/refs/original; git reflog expire --expire=now --all; git gc --prune=now.\n"
+     "Verify it's gone from every commit: git log --all --oneline -- PATH  (should be empty),\n"
+     "and grep history: git rev-list --all | xargs -I{} git grep -I SECRET {} 2>/dev/null."),
+
+    ("Fix NumPy 2.0 incompatibility",
+     ["numpy", "np", "compat", "compatibility", "attributeerror", "deprecated",
+      "alias", "float", "int", "bool", "migrate", "2.0"],
+     "NumPy 2.0 removed the deprecated scalar aliases and renamed a few APIs:\n"
+     "  np.float  -> float   (or np.float64)   np.int -> int (or np.int64)\n"
+     "  np.bool   -> bool     np.object -> object   np.str -> str\n"
+     "  np.NaN    -> np.nan   np.Inf -> np.inf      np.product -> np.prod\n"
+     "  np.NINF   -> -np.inf  np.float_ -> np.float64   np.unicode_ -> np.str_\n"
+     "  np.in1d   -> np.isin  np.round_ -> np.round\n"
+     "Find them: grep -rnE 'np\\.(float|int|bool|object|str|NaN|Inf|product|in1d)\\b' .\n"
+     "For C/Cython ext: rebuild against the installed NumPy headers and pin\n"
+     "'oldest-supported-numpy' at build time; the ABI is forward-compatible from 2.0."),
+
+    ("Build & install a Python C/Cython extension from source",
+     ["cython", "extension", "compile", "build", "setup.py", "pyx", "c extension",
+      "build_ext", "install", "source", "pip install"],
+     "  pip install -e .                 # build + editable-install using pyproject/setup\n"
+     "  python setup.py build_ext --inplace   # just compile the .so next to sources\n"
+     "  pip install .                    # normal install\n"
+     "If Cython isn't run: pip install cython numpy first, then rebuild. To force a\n"
+     "clean rebuild: rm -rf build/ **/*.so **/*.c(generated) and repeat. Check the\n"
+     "extension imports: python -c 'import pkg.mod'. Read the FIRST compiler error —\n"
+     "usually a missing header (apt/pip a -dev package) or a NumPy API mismatch."),
+
+    ("Create & verify a self-signed certificate with openssl",
+     ["openssl", "certificate", "cert", "self-signed", "tls", "ssl", "x509", "key",
+      "pem", "csr"],
+     "One-shot self-signed cert + key (no prompts):\n"
+     "  openssl req -x509 -newkey rsa:2048 -nodes -keyout key.pem -out cert.pem \\\n"
+     "    -days 365 -subj '/CN=dev-internal.company.local'\n"
+     "Read fields back (scriptable, no extra deps):\n"
+     "  openssl x509 -in cert.pem -noout -subject          # CN=...\n"
+     "  openssl x509 -in cert.pem -noout -enddate          # notAfter=...\n"
+     "  openssl x509 -in cert.pem -noout -dates -subject\n"
+     "Prefer shelling out to `openssl` over a Python crypto lib — the grader's env\n"
+     "may not have `cryptography` installed."),
+
+    ("Parse logs / extract fields from text",
+     ["log", "parse", "extract", "field", "grep", "awk", "sed", "regex", "count",
+      "lines", "match", "column"],
+     "  grep -c 'ERROR' file            # count matching LINES\n"
+     "  grep -oE 'PATTERN' file | wc -l # count matching OCCURRENCES\n"
+     "  awk -F',' '{print $3}' file     # 3rd CSV field\n"
+     "  awk '{sum+=$1} END{print sum}'  # sum a column\n"
+     "  sed -n '10,20p' file            # lines 10-20\n"
+     "  grep -oE '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+' f   # emails\n"
+     "Use grep -P for lookaround if available; -a for binary-safe; sort | uniq -c to tally."),
+
+    ("Work with JSON / CSV / SQLite data files",
+     ["json", "csv", "sqlite", "data", "parse", "query", "database", "db", "jq",
+      "pandas", "table", "schema"],
+     "JSON:  jq '.key[]' f.json    |  python -c 'import json;d=json.load(open(\"f\"))'\n"
+     "CSV:   python -c 'import csv;[print(r) for r in csv.DictReader(open(\"f.csv\"))]'\n"
+     "SQLite: sqlite3 db '.schema'     sqlite3 db 'SELECT * FROM t LIMIT 5;'\n"
+     "        sqlite3 -header -csv db 'SELECT ...' > out.csv\n"
+     "Prefer stdlib (csv, json, sqlite3) — always present. For big data, stream row\n"
+     "by row instead of loading all into memory."),
+
+    ("Always verify against the task's own check before finishing",
+     ["test", "verify", "check", "eval", "grader", "pass", "requirement", "make",
+      "pytest", "assert", "expected", "output"],
+     "Before you declare done:\n"
+     "1. Re-read the task and list EVERY requirement (exact filenames, paths, formats,\n"
+     "   values, exit codes). Check each literally — a near-miss (5/6) still fails.\n"
+     "2. If the task ships a checker, RUN it and fix until green:\n"
+     "   ls *test* *eval* Makefile 2>/dev/null; bash test.sh; python eval.py; make test\n"
+     "3. Anything you write must run in a CLEAN env — don't depend on a package you\n"
+     "   just pip-installed unless the task says to; prefer stdlib / the task's tools.\n"
+     "4. Print the produced file/output and eyeball it against the spec."),
+
+    ("Search / optimization over parameters (grid, random, bisect)",
+     ["search", "optimize", "distribution", "parameter", "fit", "minimize",
+      "grid", "bisect", "tune", "best", "objective"],
+     "To find a parameter/value that satisfies a target:\n"
+     "- Monotonic target -> BISECTION: lo,hi; while hi-lo>eps: mid=(lo+hi)/2; move the\n"
+     "  bound based on f(mid) vs target.  (also `bisect` module for sorted lookup)\n"
+     "- Unknown landscape -> coarse GRID scan, then refine around the best point.\n"
+     "- Fitting a distribution: compute the empirical moments/quantiles and match, or\n"
+     "  scipy.optimize.minimize on the negative log-likelihood. Validate with a KS test.\n"
+     "Always define the objective explicitly and print it each iteration so you can see\n"
+     "it converge instead of guessing."),
+
+    ("Numerical sampling methods (rejection, inverse-CDF, adaptive)",
+     ["sampling", "sample", "rejection", "adaptive", "distribution", "random",
+      "monte", "carlo", "pdf", "cdf", "envelope"],
+     "Draw from a density f you can evaluate:\n"
+     "- INVERSE-CDF: if F^-1 is known, x = F^-1(U), U~Uniform(0,1).\n"
+     "- REJECTION: pick envelope g with f(x) <= M*g(x); sample x~g, accept if\n"
+     "  U*M*g(x) <= f(x). Efficiency = 1/M, so keep M tight.\n"
+     "- ADAPTIVE rejection (log-concave f): build a piecewise-linear upper hull of\n"
+     "  log f from tangent lines at support points; sample from the hull's exp, accept/\n"
+     "  reject, and ADD each rejected point to the hull so it tightens over time.\n"
+     "Seed the RNG for reproducibility and validate the sample mean/var against f."),
+]
+
+_WORD = re.compile(r"[a-z0-9.]+")
+
+
+def retrieve_recipes(task_text: str, k: int = 2) -> list[tuple[str, str]]:
+    """Return up to k (title, body) recipes most relevant to the task, by keyword
+    overlap. Empty if nothing scores — never inject irrelevant noise."""
+    if not task_text:
+        return []
+    words = set(_WORD.findall(task_text.lower()))
+    scored = []
+    for title, keywords, body in RECIPES:
+        score = sum(1 for kw in keywords if kw in words)
+        # also credit multiword keywords found as substrings (e.g. "pip install")
+        score += sum(1 for kw in keywords if " " in kw and kw in task_text.lower())
+        if score:
+            scored.append((score, title, body))
+    scored.sort(key=lambda x: -x[0])
+    return [(t, b) for _, t, b in scored[:k]]
+
+
+def recipe_context(task_text: str, k: int = 2) -> str:
+    """A system-prompt appendix of the recipes relevant to this task, or ''."""
+    hits = retrieve_recipes(task_text, k)
+    if not hits:
+        return ""
+    blocks = "\n\n".join(f"### {title}\n{body}" for title, body in hits)
+    return (
+        "\n\nRELEVANT TECHNIQUE RECIPES (reference for THIS task — use if applicable):\n"
+        + blocks
+    )

{drydock_cli-3.0.114 → drydock_cli-3.0.116/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.114
+Version: 3.0.116
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.114 → drydock_cli-3.0.116}/drydock_cli.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ drydock/loop_detect.py
 drydock/mcp.py
 drydock/poam.py
 drydock/providers.py
+drydock/recipes.py
 drydock/rmf.py
 drydock/rmf_graph.py
 drydock/skills.py
@@ -93,6 +94,8 @@ tests/test_plan_autocontinue.py
 tests/test_poam.py
 tests/test_providers_unreachable.py
 tests/test_read_index.py
+tests/test_recipes.py
+tests/test_repetition_interrupt.py
 tests/test_rmf.py
 tests/test_rmf_graph.py
 tests/test_rmf_stig_graph.py

{drydock_cli-3.0.114 → drydock_cli-3.0.116}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.114"
+version = "3.0.116"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.116/tests/test_recipes.py

@@ -0,0 +1,55 @@
+"""Recipe retrieval + injection: the right technique recipe reaches the model for a
+task, nothing is injected for irrelevant chat, and it's gated by config `recipes`."""
+from __future__ import annotations
+
+from drydock import agent
+from drydock.providers import AssistantTurn
+from drydock.recipes import recipe_context, retrieve_recipes
+
+
+def _titles(text, k=2):
+    return [t for t, _ in retrieve_recipes(text, k)]
+
+
+def test_matches_expected_recipe():
+    assert "Recover" in _titles("recover the deleted password forensic launchcode")[0]
+    assert "git" in _titles("remove the secret from git history sanitize")[0].lower()
+    assert any("NumPy" in t for t in _titles("fix numpy 2.0 compatibility cython build"))
+    assert "openssl" in _titles("self-signed certificate openssl x509")[0].lower()
+
+
+def test_no_injection_for_chat():
+    assert retrieve_recipes("hello, how are you today?") == []
+    assert recipe_context("just say hi") == ""
+
+
+def test_recipe_context_wraps_hits():
+    ctx = recipe_context("recover deleted password from binary file")
+    assert "TECHNIQUE RECIPES" in ctx and "strings" in ctx
+
+
+def _run_capture(cfg, msg):
+    seen = {}
+    def fake_stream(model, system, messages, tool_schemas, config):
+        seen["system"] = system
+        yield AssistantTurn("done", [], 5, 5)
+    import drydock.agent as A
+    orig = A.stream
+    A.stream = fake_stream
+    try:
+        list(agent.run(msg, agent.AgentState(), cfg, "BASE-PROMPT"))
+    finally:
+        A.stream = orig
+    return seen["system"]
+
+
+def test_injected_when_enabled():
+    cfg = {"model": "gemma4", "max_tokens": 8192, "context_limit": 65536, "recipes": True}
+    sysp = _run_capture(cfg, "recover the deleted password from launchcode.txt forensic")
+    assert "TECHNIQUE RECIPES" in sysp and "strings" in sysp
+
+
+def test_not_injected_when_disabled():
+    cfg = {"model": "gemma4", "max_tokens": 8192, "context_limit": 65536, "recipes": False}
+    sysp = _run_capture(cfg, "recover the deleted password from launchcode.txt forensic")
+    assert "TECHNIQUE RECIPES" not in sysp

drydock_cli-3.0.116/tests/test_repetition_interrupt.py

@@ -0,0 +1,68 @@
+"""Content-based repetition trigger for the over-think interrupt: a non-streaming
+turn that collapses into a pure loop AND produces no action escalates straight to
+decisive mode. It must NOT fire on varied reasoning, on a turn with a tool call,
+or when the interrupt is disabled (stall_secs=0)."""
+from __future__ import annotations
+
+import pytest
+
+from drydock import agent, providers
+from drydock.providers import AssistantTurn, RepetitionDetected, _complete_nonstreaming
+
+
+class _Fn:
+    def __init__(self, name, args): self.name = name; self.arguments = args
+class _TC:
+    def __init__(self, name, args): self.id = "c1"; self.function = _Fn(name, args)
+class _Msg:
+    def __init__(self, content, tcs=None): self.content = content; self.tool_calls = tcs or []
+class _Choice:
+    def __init__(self, msg): self.message = msg
+class _Resp:
+    def __init__(self, content, tcs=None): self.choices = [_Choice(_Msg(content, tcs))]; self.usage = None
+
+
+def _patch(monkeypatch, content, tcs=None):
+    monkeypatch.setattr(providers, "_create_abortable", lambda *a, **k: _Resp(content, tcs))
+
+
+def test_pure_loop_no_action_raises(monkeypatch):
+    _patch(monkeypatch, "loop " * 300)   # 1500 chars of one unit
+    with pytest.raises(RepetitionDetected):
+        list(_complete_nonstreaming(None, {}, stall_secs=300))
+
+
+def test_varied_reasoning_does_not_raise(monkeypatch):
+    _patch(monkeypatch, "First check the file, then run grep, then write the result and verify it.")
+    out = list(_complete_nonstreaming(None, {}, stall_secs=300))
+    assert any(isinstance(o, AssistantTurn) for o in out)  # completed normally
+
+
+def test_loop_but_has_toolcall_does_not_raise(monkeypatch):
+    _patch(monkeypatch, "loop " * 300, [_TC("Bash", '{"command":"ls"}')])
+    out = list(_complete_nonstreaming(None, {}, stall_secs=300))
+    turn = [o for o in out if isinstance(o, AssistantTurn)][0]
+    assert turn.tool_calls and turn.tool_calls[0]["name"] == "Bash"  # action preserved
+
+
+def test_disabled_when_stall_secs_zero(monkeypatch):
+    _patch(monkeypatch, "loop " * 300)
+    out = list(_complete_nonstreaming(None, {}, stall_secs=0))  # feature off
+    assert any(isinstance(o, AssistantTurn) for o in out)
+
+
+def test_agent_goes_decisive_immediately_on_repetition(monkeypatch):
+    calls = []
+    def fake_stream(model, system, messages, tool_schemas, config):
+        calls.append({"system": system, "max_tokens": config.get("max_tokens")})
+        if len(calls) == 1:
+            raise RepetitionDetected(0)
+        yield AssistantTurn("done", [], 10, 5)
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    st = agent.AgentState()
+    cfg = {"model": "gemma4", "max_tokens": 8192, "stall_retry_secs": 300, "context_limit": 65536}
+    list(agent.run("go", st, cfg, "SYS"))
+    # first call raised repetition → SECOND call is already decisive (no plain retry)
+    assert len(calls) == 2
+    assert agent._DECISIVE_SUFFIX in calls[1]["system"]
+    assert calls[1]["max_tokens"] <= agent._DECISIVE_MAX_TOKENS