drydock-cli 2.9.55__tar.gz → 2.9.59__tar.gz

{drydock_cli-2.9.55 → drydock_cli-2.9.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.9.55
+Version: 2.9.59
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via llama.cpp
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.9.55 → drydock_cli-2.9.59}/drydock/admiral/opus_escalator.py

@@ -39,7 +39,7 @@ the user, say so explicitly.
 
 Detector: {code}
 Admiral's canned fallback: "{fallback}"
-
+{loop_constraint}
 Recent conversation:
 <conversation>
 {context}
@@ -110,10 +110,20 @@ async def escalate(
     messages: Sequence[LLMMessage],
 ) -> str | None:
     """Ask Opus for a directive. Returns directive text or None."""
+    loop_constraint = ""
+    if finding.code.startswith("loop:bash::"):
+        cmd_snippet = finding.code[len("loop:bash::"):][:120]
+        loop_constraint = (
+            f"\nCRITICAL CONSTRAINT: The repeated command is `bash` with "
+            f"args `{cmd_snippet}`. Your directive MUST NOT suggest running "
+            f"this same command again — the model already has its output. "
+            f"Direct the agent to read/edit source code instead.\n"
+        )
     prompt = _OPUS_PROMPT.format(
         rubric=_DIRECTIVES_RUBRIC,
         code=finding.code,
         fallback=finding.directive[:200],
+        loop_constraint=loop_constraint,
         context=_render_turns(messages, n_turns=12),
     )
     out = await _try_anthropic_sdk(prompt)

{drydock_cli-2.9.55 → drydock_cli-2.9.59}/drydock/core/agent_loop.py

@@ -1680,6 +1680,70 @@ class AgentLoop:
                         expected_paths = list(dict.fromkeys(pat.findall(task_text)))[:10]
                     missing_expected = [p for p in expected_paths if p not in written_paths]
                     has_expected_misses = bool(expected_paths and missing_expected)
+
+                    # Fix E (2026-06-04): parse the task instruction for
+                    # explicit verify commands and check if the model has
+                    # ever run them. Targets the partial-pytest-credit
+                    # cluster — fix-code-vulnerability scored 5/6 pytest
+                    # but never ran the explicit `pytest -rA` the task
+                    # named. Same shape across 14 trials in v2.9.55 batch.
+                    expected_verifies: list[str] = []
+                    if len(self.messages) >= 2:
+                        task_text = (self.messages[1].content or "")
+                        import re as _re2
+                        # Patterns the model should run before exit:
+                        # - "you can run: `pytest -rA`"
+                        # - "verify by running `bash test.sh`"
+                        # - "to test, run `python test.py`"
+                        # - bare `pytest` mentions in instructions
+                        # Capture the command text (inside backticks first).
+                        cmd_patterns = [
+                            r"(?:you can run|verify by running|to test,?\s*run|"
+                            r"to verify,?\s*run|run the tests? with|tests? are run with|"
+                            r"verifier runs?|you may run|run\s+the\s+command|"
+                            r"to evaluate|evaluation command):\s*`([^`]+)`",
+                            r"verify by:?\s*`([^`]+)`",
+                            # bare backtick commands containing pytest/bash/make
+                            r"`(pytest\s[^`]*|bash\s+[^`]*\.sh[^`]*|make\s+test[^`]*|"
+                            r"npm\s+test[^`]*|cargo\s+test[^`]*|go\s+test[^`]*)`",
+                        ]
+                        for p in cmd_patterns:
+                            for m in _re2.finditer(p, task_text, _re2.IGNORECASE):
+                                cmd = m.group(1).strip()
+                                if cmd and cmd not in expected_verifies:
+                                    expected_verifies.append(cmd)
+                                    if len(expected_verifies) >= 5:
+                                        break
+                            if len(expected_verifies) >= 5:
+                                break
+                    # Did the model run any matching command via bash?
+                    ran_verify_cmds: list[str] = []
+                    if expected_verifies:
+                        bash_cmds: list[str] = []
+                        for msg in self.messages:
+                            for tc in (msg.tool_calls or []):
+                                fn_obj = tc.function
+                                if not fn_obj or fn_obj.name != "bash":
+                                    continue
+                                try:
+                                    import json as _json2
+                                    a = _json2.loads(fn_obj.arguments or "{}")
+                                    c = a.get("command") or ""
+                                    if c:
+                                        bash_cmds.append(c)
+                                except Exception:
+                                    pass
+                        # Match: any token of the expected command appears in
+                        # any of the model's bash commands. Lenient match
+                        # (model might add extra flags or paths).
+                        for ev in expected_verifies:
+                            first_token = ev.split()[0] if ev.split() else ev
+                            if any(first_token in bc for bc in bash_cmds):
+                                ran_verify_cmds.append(ev)
+                    missing_verify_cmds = [
+                        ev for ev in expected_verifies if ev not in ran_verify_cmds
+                    ]
+                    has_missing_verify = bool(missing_verify_cmds)
                     # Cap raised 5 → 10 nudges per session. Removed tool_turns
                     # gate entirely — the 2026-06-03 v2948 batch showed that
                     # most "engaged but failed" trials (bucket D, 26/50 fails)
@@ -1690,16 +1754,24 @@ class AgentLoop:
                     # The verifier never ran for any of them. Nudging late
                     # forces them to run the verifier and iterate.
                     #
-                    # Also count `verify` tool calls. If the model emitted a
-                    # `verify` call recently AND it returned passed=True, do
-                    # NOT nudge — the model genuinely passed its check.
+                    # Count `verify` tool calls for the nudge text. Note:
+                    # `last_verify_passed` is NOT used as a gate anymore.
+                    # 2026-06-04 v2.9.55 batch: the model's `verify` tool
+                    # checks MODEL-CHOSEN criteria, not the external tbench
+                    # verifier. Self-pass happens easily (chess-best-move had
+                    # 4 verify calls, last passed=True, model's answer was
+                    # wrong, external tbench verifier rejected). Using
+                    # last_verify_passed as a gate silenced the nudge across
+                    # 37/37 fails in that batch. The nudge cap (10) is
+                    # already a sufficient bound; let it fire so Fix A
+                    # (path-aware nudge) actually runs.
                     verify_count = 0
                     last_verify_passed = False
                     for msg in self.messages:
                         if msg.role == Role.tool and (msg.name == "verify"):
                             verify_count += 1
                             last_verify_passed = "passed: True" in (msg.content or "")
-                    if is_programmatic and nudges < 10 and not last_verify_passed:
+                    if is_programmatic and nudges < 10:
                         self._premature_exit_nudges = nudges + 1
                         if zero_writes:
                             paths_hint = ""
@@ -1740,6 +1812,44 @@ class AgentLoop:
                                 f"no file, and partial-credit verifiers reward "
                                 f"format correctness even when content is off."
                             )
+                        elif has_missing_verify:
+                            # Fix E (2026-06-04): task explicitly names a
+                            # verify command (e.g. "you can run: `pytest -rA`")
+                            # and the model never executed it. 14 of 37 fails
+                            # in v2.9.55 had partial pytest credit (one named
+                            # 5/6, another 4/5) — they were ONE iteration away
+                            # from passing but never ran the verifier to see.
+                            note = (
+                                f"⚠ PREMATURE EXIT BLOCK #{nudges + 1}/10. "
+                                f"The task explicitly names this verify "
+                                f"command: `{missing_verify_cmds[0]}`"
+                                f"{' (+%d more)' % (len(missing_verify_cmds)-1) if len(missing_verify_cmds) > 1 else ''}"
+                                f". You have NOT run it. The external "
+                                f"verifier will use that exact command (or "
+                                f"equivalent) after you exit — run it NOW "
+                                f"yourself via `bash`, READ every failure "
+                                f"line, FIX what it reports, then rerun "
+                                f"until 0 failures. Your self-`verify` tool "
+                                f"checks YOUR criterion, not this command."
+                            )
+                        elif last_verify_passed:
+                            # 2026-06-04: model self-verified with its OWN
+                            # criterion. Real tbench/pytest verifier runs
+                            # later and is stricter. Warn explicitly.
+                            note = (
+                                f"⚠ PREMATURE EXIT BLOCK #{nudges + 1}/10. "
+                                f"Your `verify` call passed, but that checks "
+                                f"the criterion YOU wrote — not the external "
+                                f"pytest the harness will run after you exit. "
+                                f"Common gap: your verify checks 'file exists' "
+                                f"or 'output contains X', but the verifier "
+                                f"checks EXACT format / EXACT path / specific "
+                                f"line content. Re-read the task literally: "
+                                f"the path it names, the format it specifies, "
+                                f"the example outputs it shows. Run a stricter "
+                                f"check (cat the file, run pytest if installed, "
+                                f"diff against the example) BEFORE exiting."
+                            )
                         else:
                             note = (
                                 f"⚠ PREMATURE EXIT BLOCK #{nudges + 1}/10. "
@@ -2550,7 +2660,13 @@ class AgentLoop:
         # Read-only checks (ls, pwd, git status) get a higher threshold.
         tool_name = tool_call.tool_name
         is_readonly = tool_name in ("grep", "read_file", "glob", "ls")
-        success_threshold = 6 if is_readonly else 4
+        # 2026-06-04: lowered read-only success threshold 6 → 3 after
+        # operator TUI session showed read_file looping 7× on the same
+        # file before circuit breaker fired. The tool already injects a
+        # "2nd identical read" header; if the model hasn't pivoted by
+        # the 3rd call, it never will. Cuts wasted-turn cost on stuck
+        # models from ~6 to ~3 per loop.
+        success_threshold = 3 if is_readonly else 4
 
         if is_failed and count >= 2:
             pass  # will be blocked below

{drydock_cli-2.9.55 → drydock_cli-2.9.59}/drydock/core/tools/builtins/write_file.py

@@ -451,6 +451,27 @@ class WriteFile(
         # triggers panic-retry loops (feedback_no_tool_errors_for_loop_detection).
         if not args.path.strip():
             cwd = Path.cwd()
+            # Track consecutive missing-path attempts so the advisory can
+            # escalate from gentle → concrete-suggestion → hard-block.
+            # 2026-06-04: operator reported 3+ identical missing-path
+            # attempts in TUI session — the soft advisory wasn't enough.
+            miss_state = self.state.__dict__.setdefault(
+                "_write_file_missing_path_streak", 0
+            )
+            miss_state += 1
+            self.state.__dict__["_write_file_missing_path_streak"] = miss_state
+
+            # Pull last-read paths from the read-file state for concrete
+            # suggestions on retry.
+            read_state = ctx.read_file_state if ctx else None
+            recent_reads: list[str] = []
+            if read_state:
+                try:
+                    # read_file_state is keyed by path; pull a stable list
+                    recent_reads = list(read_state.keys())[-3:]
+                except Exception:
+                    pass
+
             try:
                 pkg_dirs = [
                     d.name for d in sorted(cwd.iterdir())
@@ -459,29 +480,56 @@ class WriteFile(
                 hint = f"Package dirs in {cwd.name}/: {', '.join(pkg_dirs)}" if pkg_dirs else f"cwd: {cwd}"
             except OSError:
                 hint = f"cwd: {cwd}"
-            # 2026-05-31: do NOT echo a sample call shape in the error
-            # content. Gemma 4 copies whatever it sees from prior tool
-            # results as the next call's args — a literal call-syntax
-            # template in the error message gets re-emitted as the next
-            # call (operator session 2026-05-31 hit 5+ identical
-            # empty-path errors in a row). Keep the error terse and
-            # actionable; the tool schema in the system prompt is the
-            # canonical reference, not the error message. Same
-            # root-cause as the search_replace empty-call loop fixed
-            # via dedup-strip in commit dee310a.
-            yield WriteFileResult(
-                path="(missing)",
-                bytes_written=0,
-                file_existed=False,
-                content=(
+
+            if miss_state == 1:
+                # 2026-05-31: do NOT echo a sample call shape in the
+                # error content. Gemma 4 copies whatever it sees from
+                # prior tool results as the next call's args — a
+                # literal call-syntax template in the error message
+                # gets re-emitted as the next call. Keep terse.
+                msg = (
                     f"NO path supplied. Pick a concrete file path "
                     f"under the current project (e.g. one of the "
                     f"existing source files you just read), then "
                     f"re-emit the call with that path and the full "
                     f"file content. {hint}."
-                ),
+                )
+            elif miss_state == 2 and recent_reads:
+                # Escalate: name the actual recently-read files so the
+                # model has a concrete target. Removes ambiguity that
+                # caused the model to retry with the same empty args.
+                msg = (
+                    f"[REPEAT #{miss_state}] write_file STILL called with "
+                    f"NO path. Stop guessing — pick ONE of these files "
+                    f"you just read and pass its FULL absolute path as "
+                    f"`path`: {', '.join(recent_reads[:3])}. If none "
+                    f"of these is right, call read_file on the file "
+                    f"you intend to edit FIRST, then write_file with "
+                    f"that exact path."
+                )
+            else:
+                # 3rd+ miss with no recoverable suggestion. Block harder
+                # so the agent loop's "no progress" detector kicks in.
+                msg = (
+                    f"[HARD-BLOCK] write_file called with NO path "
+                    f"{miss_state} times in a row. STOP calling "
+                    f"write_file. Do one of: (1) call read_file on the "
+                    f"file you intend to edit so its path enters my "
+                    f"context, (2) call bash with `ls` or `find` to "
+                    f"locate the target file, (3) end your turn with a "
+                    f"text summary if you're stuck. Continuing to call "
+                    f"write_file without a path will produce this same "
+                    f"block — it is not progress."
+                )
+            yield WriteFileResult(
+                path="(missing)",
+                bytes_written=0,
+                file_existed=False,
+                content=msg,
             )
             return
+        # Reset the missing-path streak on a successful path arg.
+        self.state.__dict__["_write_file_missing_path_streak"] = 0
         file_path, file_existed, content_bytes = self._prepare_and_validate_path(args)
 
         # Read-before-Write enforcement (Claude Code tool contract).

{drydock_cli-2.9.55 → drydock_cli-2.9.59}/drydock/curiosity/gap_detector.py

@@ -43,6 +43,8 @@ _STOPWORDS: frozenset[str] = frozenset({
     # because they always lead a Title-Case phrase ("Consider the X").
     "Consider", "Suppose", "Given", "Let", "Define", "Compute",
     "Determine", "Evaluate", "Prove", "Recall", "Note", "Assume",
+    "Render", "Parse", "Scan", "Detect", "Match", "Merge",
+    "Insert", "Delete", "Select", "Update", "Create", "Drop",
 })
 
 # HLE / harness prompt-template tokens that the detector kept flagging
@@ -99,10 +101,98 @@ _TEMPLATE_NOISE: frozenset[str] = frozenset(
         # knowledge gap — 2026-06-04 queue audit top false positives.
         "ERROR", "WARNING", "INFO", "DEBUG", "CRITICAL", "FATAL",
         "TRACE", "VERBOSE", "NOTICE",
+        # HTTP methods — always known in coding context.
+        "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "CONNECT",
+        # HTTP/web protocol abbreviations.
+        "SSE", "WS", "WSS", "RPC", "JSONRPC",
+        # Web/style formats.
+        "CSS", "SASS", "SCSS", "LESS",
+        # Common programming concepts always known in coding context.
+        "AST", "CFG", "DAG", "FSM", "DSL", "BNF", "EBNF", "REPL",
+        # Caching strategies.
+        "LRU", "LFU", "FIFO", "LIFO", "MRU",
+        # Encoding names with hyphen variants.
+        "UTF-8", "UTF-16", "UTF-32",
+        # Common placeholder / schema column-type words.
+        "VALUE", "DATE", "TIME", "SIZE", "HASH", "RANK",
+        # Project doc file names always known to a coding assistant.
+        "FAQ", "CONTRIBUTING", "AUTHORS", "CODEOWNERS", "SECURITY",
+        "MAINTAINERS", "NOTICE",
+        # Connector prepositions that match short-string regexes but are prose.
+        "IN", "OF", "AT", "ON", "BY", "AS",
+        # PRD section headers — always prose in template specs, not entities.
+        "OPEN QUESTIONS", "USE CASES", "NON-GOALS", "NON GOALS",
+        "EDGE CASES", "GETTING STARTED", "QUICK START", "OVERVIEW",
+        "BACKGROUND", "MOTIVATION", "RATIONALE", "OBJECTIVES", "SCOPE",
+        # Pytest / CI test-status words — appear as "pytest is RED / GREEN"
+        # in task prompts but are never GraphRAG-retrievable knowledge.
+        "RED", "GREEN", "PASS", "FAIL", "SKIP", "XFAIL",
+        "PASSED", "FAILED", "SKIPPED", "BROKEN", "XPASS",
         "STATUS", "STATE", "MODE", "TYPE", "KIND", "FLAG", "OPTION",
         "FINDINGS", "PATTERNS", "REGEXES", "FIELDS", "METHODS",
         "VERSION", "NAME", "PATH", "DATA", "OUTPUT", "INPUT",
         "CONFIG", "SCHEMA", "FORMAT", "TEMPLATE", "LAYOUT",
+        # SQL DDL keywords — written in ALL-CAPS in schema code but never
+        # a GraphRAG knowledge gap for a coding assistant.
+        "TEXT", "INTEGER", "REAL", "BLOB", "BOOLEAN", "NUMERIC",
+        "PRIMARY", "KEY", "UNIQUE", "INDEX", "FOREIGN", "REFERENCES",
+        "CONSTRAINT", "DEFAULT", "NOT NULL", "NULL", "AUTO INCREMENT",
+        "CREATE", "TABLE", "SELECT", "INSERT", "UPDATE", "DELETE",
+        "FROM", "WHERE", "JOIN", "LEFT", "RIGHT", "INNER", "OUTER",
+        "GROUP BY", "ORDER BY", "HAVING", "LIMIT", "OFFSET",
+        "BEGIN", "COMMIT", "ROLLBACK", "TRANSACTION",
+        # Common English words used in ALL-CAPS for emphasis in user specs —
+        # they match _RE_ACRONYM (≥3 uppercase) but carry no knowledge gap.
+        "OFFLINE", "ONLINE", "LOCAL", "REMOTE", "ALWAYS", "NEVER",
+        "ONLY", "ALSO", "MUST", "SHOULD", "WILL", "FULL", "EMPTY",
+        "DONE", "NEXT", "LAST", "FIRST", "EACH", "BOTH", "SAME",
+        "EVERY", "KEEP", "NEED", "ABLE", "MAKE", "WRITE", "READ",
+        "STORE", "CACHE", "DISK", "FILE", "PARSE", "LOAD", "CALL",
+        "SEND", "RECV", "OPEN", "CLOSE", "INIT", "STOP", "WAIT",
+        "SYNC", "ASYNC", "COPY", "MOVE", "PUSH", "PULL", "FETCH",
+        # Temporal conjunctions/prepositions used for emphasis in specs
+        "BEFORE", "AFTER", "DURING", "WHILE", "SINCE", "UNTIL",
+        "WHEN", "THEN", "ONCE", "ALREADY", "STILL", "AGAIN",
+        "ACROSS", "BETWEEN", "WITHIN", "WITHOUT", "THROUGH",
+        "ABOVE", "BELOW", "UNDER", "OVER", "INTO", "ONTO", "FROM",
+        "AGAINST", "BEYOND", "DESPITE", "EXCEPT", "INSTEAD",
+        "CLARIFICATION", "IMPLEMENTATION", "REQUIREMENT", "SPECIFICATION",
+        "DEFINITION", "DESCRIPTION", "DOCUMENTATION", "EXAMPLE",
+        "FEATURE", "FUNCTION", "INTERFACE", "PROPERTY", "ATTRIBUTE",
+        "INSTANCE", "OBJECT", "CLASS", "MODULE", "PACKAGE", "LIBRARY",
+        "MILK",  # from "buy milk" test prompt — common English word
+        # Single-word emphasis — match _RE_ACRONYM (≥3 uppercase) but are
+        # common English words used for stress in PRD specs, not identifiers.
+        "ONE", "OLD", "END", "POST", "MOSTLY", "QUITE", "VERY",
+        # Networking / infra abbreviations always known in coding context.
+        "TTL", "ACL", "NAT", "DNS", "VPN", "LAN", "WAN",
+        # Product / project management abbreviations used in PRD prompts.
+        "PRD", "RFC", "ADR", "SLA", "SLO", "SLI", "KPI", "OKR",
+        # iCalendar (RFC 5545) protocol keywords — appear in iCal-format PRDs.
+        "VCALENDAR", "VEVENT", "VTODO", "VJOURNAL", "VALARM",
+        "DTSTART", "DTEND", "DTSTAMP", "DURATION", "RRULE",
+        # Common English nouns used as PRD field / attribute names — never a
+        # GraphRAG knowledge gap. 2026-06-04 queue audit: recency (215×),
+        # tasks (188×), untitled (67×), username (65×).
+        "recency", "tasks", "untitled", "username", "summary",
+        "legacy", "snapshot", "artifact", "payload", "metadata",
+        "endpoint", "workflow", "pipeline", "plugin", "widget",
+        "sidebar", "toolbar", "viewport", "canvas", "panel",
+        "dialog", "modal", "popup", "tooltip", "banner", "badge",
+        # Well-known infrastructure / framework names always known to a coding
+        # assistant — appear as lowercase terms in stress-run sessions where
+        # the model is asked to add support for common servers/tools.
+        "nginx", "gunicorn", "uwsgi", "celery", "supervisor",
+        "flask", "django", "fastapi", "tornado", "aiohttp", "bottle",
+        "pytest", "unittest", "nose", "tox",
+        "pandas", "numpy", "scipy", "matplotlib", "seaborn", "sklearn",
+        "docker", "kubernetes", "helm", "terraform", "ansible",
+        "webpack", "vite", "rollup", "esbuild", "babel",
+        # Generic technical snake_case nouns that are code-artifact names,
+        # not external library knowledge gaps.
+        "stack_trace", "word_count", "line_count", "byte_count", "char_count",
+        "legacy_modules", "legacy_module", "legacy_code",
+        "drydock_lifecycle", "drydock_test",
     }
 )
 
@@ -112,6 +202,39 @@ _CONNECTOR_WORDS: frozenset[str] = frozenset({
     "of", "the", "and", "for", "in", "de", "von", "a", "an",
 })
 
+# Snake-case identifiers that start with a common action verb are generated
+# code artifacts (CRUD methods, helpers), not external knowledge gaps.
+_VERB_PREFIXES: frozenset[str] = frozenset({
+    "get_", "set_", "add_", "put_", "has_", "is_",
+    "list_", "count_", "delete_", "remove_", "create_", "make_",
+    "build_", "update_", "edit_", "save_", "load_", "read_", "write_",
+    "parse_", "format_", "render_", "handle_", "process_", "compute_",
+    "calc_", "check_", "validate_", "fetch_", "send_", "recv_",
+    "run_", "exec_", "init_", "reset_", "clear_", "close_", "open_",
+    "find_", "search_", "query_", "filter_", "sort_", "group_",
+    "encode_", "decode_", "serialize_", "deserialize_", "convert_",
+    "show_", "hide_", "display_", "print_", "log_", "report_",
+    "sample_", "generate_", "emit_", "merge_", "patch_", "register_",
+    "unregister_", "subscribe_", "publish_", "notify_", "watch_",
+    "require_", "resolve_", "dispatch_", "route_", "map_", "reduce_",
+    "collect_", "gather_", "aggregate_", "transform_", "extract_",
+    "inject_", "wrap_", "unwrap_", "clone_", "copy_", "move_",
+    "import_", "export_", "upload_", "download_", "stream_",
+    "test_", "assert_", "expect_", "mock_", "stub_", "spy_",
+    # Architecture-layer prefixes — snake_case with these prefixes are
+    # internal variables/types, not external library knowledge gaps.
+    "backend_", "frontend_", "status_", "top_", "base_", "main_",
+    "core_", "util_", "helper_", "common_", "shared_", "default_",
+    "current_", "prev_", "next_", "max_", "min_", "total_", "avg_",
+    "num_", "idx_", "pos_", "key_", "val_", "src_", "dst_", "tmp_",
+    "raw_", "cached_", "parsed_", "formatted_", "rendered_", "computed_",
+    # Format-sniffing / detection / request-field prefixes — code artifacts
+    # generated by the agent, not external library knowledge gaps.
+    "sniff_", "detect_", "infer_", "guess_",
+    "req_", "resp_", "res_", "body_", "header_", "param_",
+    "source_", "target_", "dest_", "output_", "input_",
+})
+
 
 def _is_template_noise(candidate: str) -> bool:
     """True if the candidate is HLE/admiral boilerplate, not a real term."""
@@ -144,16 +267,38 @@ def _is_template_noise(candidate: str) -> bool:
         ".toml", ".log", ".html", ".xml", ".sql", ".sh", ".rs",
         ".go", ".ts", ".js", ".jsx", ".tsx", ".css", ".scss",
         ".bak", ".tmp", ".lock", ".pid", ".gz", ".zip", ".tar",
+        ".db", ".sqlite3", ".cache", ".dat", ".bin",
     )
     if "/" not in norm and any(norm.endswith(ext) for ext in _CODE_EXTS):
         return True
     # Dotted identifier where the post-dot component is a common English
-    # word → sentence boundary artifact ("scratch.Step", "fail.Stop").
+    # word OR starts with a verb-prefix → sentence boundary artifact or
+    # code artifact ("scratch.Step", "fail.Stop", "parser.sniff_format").
     if "." in norm:
         parts = norm.split(".")
         _sw_lower = {w.lower() for w in _STOPWORDS}
         if any(p in _sw_lower for p in parts[1:]):
             return True
+        if any(any(p.startswith(vp) for vp in _VERB_PREFIXES) for p in parts[1:]):
+            return True
+        # Python stdlib module dotted names (json.loads, http.server, os.path)
+        # are always known to a coding assistant.
+        _STDLIB_MODULES: frozenset[str] = frozenset({
+            "os", "sys", "re", "io", "json", "csv", "xml", "html", "http",
+            "urllib", "email", "logging", "threading", "multiprocessing",
+            "subprocess", "socket", "ssl", "hashlib", "hmac", "uuid",
+            "datetime", "time", "calendar", "random", "math", "statistics",
+            "collections", "itertools", "functools", "operator", "copy",
+            "abc", "typing", "dataclasses", "enum", "pathlib", "shutil",
+            "tempfile", "glob", "fnmatch", "pickle", "shelve", "sqlite3",
+            "struct", "array", "queue", "heapq", "bisect", "weakref",
+            "contextlib", "inspect", "ast", "dis", "gc", "traceback",
+            "warnings", "unittest", "doctest", "pprint", "textwrap",
+            "string", "difflib", "argparse", "configparser", "platform",
+            "signal", "asyncio", "base64", "binascii", "codecs",
+        })
+        if parts[0] in _STDLIB_MODULES:
+            return True
     # LaTeX math expressions — false positives from HLE/academic prompts.
     # A term starting with $ or a LaTeX command backslash is math notation,
     # not a GraphRAG-retrievable identifier.
@@ -175,18 +320,74 @@ def _is_template_noise(candidate: str) -> bool:
     # generic utility patterns, not external library gaps.
     if norm.startswith("to_"):
         return True
+    # Snake_case names ending in common implementation-pattern suffixes are
+    # code artifacts generated by the agent, not external knowledge gaps.
+    # E.g. stack_trace, error_handler, config_manager, log_formatter.
+    _NOUN_SUFFIXES: frozenset[str] = frozenset({
+        "_trace", "_count", "_handler", "_manager", "_parser",
+        "_formatter", "_reader", "_writer", "_builder", "_factory",
+        "_registry", "_provider", "_consumer", "_producer",
+        "_iterator", "_generator", "_validator", "_serializer",
+        "_deserializer", "_encoder", "_decoder", "_processor",
+        "_executor", "_scheduler", "_dispatcher", "_router",
+        "_resolver", "_collector", "_aggregator", "_transformer",
+        "_extractor", "_injector", "_wrapper", "_observer",
+        "_listener", "_emitter", "_subscriber", "_publisher",
+        "_module", "_modules", "_helper", "_util", "_utils",
+        "_config", "_settings", "_options", "_params",
+        "_result", "_results", "_response", "_request",
+        "_context", "_session", "_client", "_server",
+        "_queue", "_stack", "_buffer", "_cache", "_store",
+        "_pool", "_cluster", "_node", "_worker", "_runner",
+        "_loop", "_cycle", "_tick", "_batch", "_chunk",
+    })
+    if "_" in norm and any(norm.endswith(s) for s in _NOUN_SUFFIXES):
+        return True
+    # Common action-verb prefixed snake_case names are code artifacts.
+    if any(norm.startswith(p) for p in _VERB_PREFIXES):
+        return True
+    # Roman numerals (MCMXCIV, XIV, etc.) — matched by _RE_ACRONYM but
+    # carry no knowledge gap for a coding assistant.
+    if len(norm) > 2 and re.match(
+        r'^m{0,4}(?:cm|cd|d?c{0,3})(?:xc|xl|l?x{0,3})(?:ix|iv|v?i{0,3})$',
+        norm
+    ) and norm:
+        return True
+    # Sentence fragments starting with a single lowercase letter then a space
+    # are contraction tails ("Don't" → "t ...", "Let's" → "s ...").  These
+    # are never retrievable identifiers.
+    if re.match(r"^[a-z] ", norm):
+        return True
     # All-lowercase multi-word phrases (e.g. "buy milk", "sample logs") —
     # quoted prose from task prompts, not identifiers worth retrieving.
     # Only filter if the *original* candidate is already lowercase — Title Case
     # phrases like "Attention Is All You Need" must still be detected.
+    # Strip punctuation before the regex so commas/periods don't block matches.
     orig = candidate.strip(" :.,;")
-    if " " in norm and orig == orig.lower() and re.match(r"^[a-z][a-z0-9 _-]+$", norm):
+    norm_alphanum = re.sub(r"[^a-z0-9 _-]", "", norm)
+    if " " in norm and orig == orig.lower() and re.match(r"^[a-z][a-z0-9 _-]+$", norm_alphanum) and len(norm_alphanum) > 3:
         return True
     # Date format strings like "YYYY-MM", "YYYY-MM-DD", "/DD/YYYY" — these
     # are template tokens that contain YYYY/MM/DD components (now in
     # TEMPLATE_NOISE) separated by punctuation but the combined string isn't.
     if re.match(r"^[/\-]?(?:yyyy|mm|dd|hh|ss)(?:[/\-](?:yyyy|mm|dd|hh|ss))+$", norm):
         return True
+    # Hyphenated lowercase adjective phrases from PRD prose
+    # ("tab-separated", "human-readable", "newline-delimited") — these are
+    # format descriptors, not library identifiers worth retrieving.
+    if re.match(r"^[a-z][a-z0-9]+-[a-z][a-z0-9]+(?:-[a-z][a-z0-9]+)*$", norm):
+        return True
+    # Paths that contain known test-run or lifecycle directories — these are
+    # ephemeral artifacts from stress/lifecycle sessions, not real projects.
+    if re.search(r"(/drydock_lifecycle/|/pytest-of-|/pytest-\d|/tmp/drydock_|/swe_bench_|/test_harness_)", norm):
+        return True
+    # Latin abbreviations used as prose connectors ("i.e", "e.g", "etc").
+    if norm in ("i.e", "e.g", "etc", "i.e.", "e.g.", "etc.", "cf.", "cf", "vs", "vs."):
+        return True
+    # Snake_case identifiers containing _to_ in the middle are converter helpers
+    # (csv_to_json, rgb_to_hex) — project-generated code artifacts, not gaps.
+    if re.match(r"^[a-z][a-z0-9]*_to_[a-z][a-z0-9_]*$", norm):
+        return True
     return False
 
 # Acronyms shorter than this are too noisy to chase ("ID", "OK", "OS").

{drydock_cli-2.9.55 → drydock_cli-2.9.59}/pyproject.toml

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

{drydock_cli-2.9.55 → drydock_cli-2.9.59}/uv.lock

@@ -326,7 +326,7 @@ wheels = [
 
 [[package]]
 name = "drydock-cli"
-version = "2.9.54"
+version = "2.9.55"
 source = { editable = "." }
 dependencies = [
     { name = "agent-client-protocol" },