localcode 0.3.19__tar.gz → 0.3.21__tar.gz

{localcode-0.3.19/src/localcode.egg-info → localcode-0.3.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.19
+Version: 0.3.21
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.19 → localcode-0.3.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.19"
+version = "0.3.21"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.19 → localcode-0.3.21}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.19"
+__version__ = "0.3.21"

{localcode-0.3.19 → localcode-0.3.21}/src/localcode/agent/app_tasks.py

@@ -5,11 +5,6 @@ from pathlib import Path
 import re
 
 
-APP_BUILD_RE = re.compile(
-    r"\b(?:build|make|create|start|scaffold|help me build)\b.{0,80}\b"
-    r"(?:app|website|site|dashboard|frontend|web app|react app|streamlit|flask app)\b",
-    re.IGNORECASE | re.DOTALL,
-)
 PARTIAL_HANDOFF_RE = re.compile(
     r"(?:\bnext steps\b|\bimplemented features so far\b|\bi have started building\b|"
     r"\bready to proceed\b|\bready to continue\b|\barchitecture overview\b|"
@@ -19,7 +14,6 @@ PARTIAL_HANDOFF_RE = re.compile(
 BLOCKING_QUESTION_RE = re.compile(r"^(?:[^?]{0,320}\?)$", re.DOTALL)
 PORT_RE = re.compile(r"(?:--port\s+|-p\s+|localhost:|127\.0\.0\.1:)(\d{2,5})")
 __all__ = [
-    "is_app_build_request",
     "looks_like_partial_handoff",
     "is_focused_blocking_question",
     "extract_port",
@@ -31,10 +25,6 @@ __all__ = [
 ]
 
 
-def is_app_build_request(user_text: str) -> bool:
-    return bool(APP_BUILD_RE.search(user_text or ""))
-
-
 def looks_like_partial_handoff(content: str) -> bool:
     return bool(PARTIAL_HANDOFF_RE.search(content or ""))
 

{localcode-0.3.19 → localcode-0.3.21}/src/localcode/agent/context.py

@@ -224,10 +224,54 @@ def _truncate_result(result: str, tool_name: str, ctx_tokens: int = 0) -> str:
 # to constants.py during the T0.1 split; re-exported at the top of
 # this module for back-compat.
 
+# Only these tools' RESULTS are safe to age. They are REPLAYABLE
+# OBSERVATIONS: their output is a snapshot of external state (the filesystem,
+# a search, a shell command) that the model can regenerate on demand by
+# re-running the exact same call. Aging them is lossless-in-effect — the model
+# can always get them back. This mirrors claude-code's `COMPACTABLE_TOOLS` set
+# (microCompact.ts) and opencode's prune (which protects non-replayable tool
+# output). Deliberately EXCLUDED: write_file / edit_file / multi_edit /
+# append_file. Their result is the DIFF of what the model just wrote — the only
+# record in history of the change it made. Aging it away is what made the model
+# "forget" what it wrote after a build failure and rewrite whole files from
+# scratch (churn). Anything we can't attribute to a replayable tool is also left
+# intact (conservative default).
+_REPLAYABLE_TOOLS: frozenset[str] = frozenset({
+    "read_file", "grep", "glob", "list_files", "bash",
+    "web_search", "web_fetch",
+})
+
+
+def _tool_names_by_call_id(messages: list[dict]) -> dict[str, str]:
+    """Map tool_call_id -> tool name by scanning assistant tool_calls, so a
+    tool-role result (which only carries `tool_call_id`) can be attributed to
+    the tool that produced it."""
+    names: dict[str, str] = {}
+    for m in messages:
+        if m.get("role") != "assistant":
+            continue
+        for tc in m.get("tool_calls") or []:
+            tc_id = tc.get("id")
+            name = ((tc.get("function") or {}).get("name") or "").strip()
+            if tc_id and name:
+                names[tc_id] = name
+    return names
+
+
+def _result_tool_name(m: dict, id_to_name: dict[str, str]) -> str:
+    """Best-effort tool name for a tool-role result: explicit `name` field if
+    present (some providers set it), else via the tool_call_id map."""
+    explicit = (m.get("name") or "").strip()
+    if explicit:
+        return explicit
+    return id_to_name.get(m.get("tool_call_id"), "")
+
+
 def _compact_old_tool_results(
     messages: list[dict], keep_recent: int = COMPACT_KEEP_RECENT_TOOL_RESULTS
 ) -> list[dict]:
-    """Return a copy of `messages` with older tool-role results summarized.
+    """Return a copy of `messages` with older REPLAYABLE-OBSERVATION tool
+    results summarized.
 
     Gated on `Feature.TOOL_RESULT_AGING` — when disabled the caller gets
     the input list back unchanged, which is what eval uses to A/B
@@ -235,27 +279,42 @@ def _compact_old_tool_results(
 
     We keep the last `keep_recent` tool results verbatim (the model usually
     only needs the recent ones to decide the next step) and replace earlier
-    ones with a compact "[summarized ...]" placeholder. `keep_recent` scales
-    with the context window (more on a big machine — see
-    `_prepare_model_messages`), so a 128K-window session preserves far more
-    raw tool output than a 16K one instead of crushing both to the same 4.
-    User/assistant/system messages pass through unchanged, and `tool_call_id`
-    is preserved so the chat protocol still reconciles ids correctly.
+    ones with a compact "[summarized ...]" placeholder — but ONLY for tools in
+    `_REPLAYABLE_TOOLS`. write_file/edit_file/multi_edit results (the diffs of
+    what the model wrote) are NEVER aged, so the model doesn't lose sight of
+    its own changes. `keep_recent` scales with the context window (more on a big
+    machine — see `_prepare_model_messages`), floored at 1 so aging never clears
+    the entire working set. User/assistant/system messages pass through
+    unchanged, and `tool_call_id` is preserved so the chat protocol still
+    reconciles ids correctly.
     """
     from ..features import Feature, is_enabled
     if not is_enabled(Feature.TOOL_RESULT_AGING):
         return messages
+    # Floor at 1 so we never age away the entire working set of tool output.
     keep_recent = max(1, keep_recent)
-    tool_idxs = [i for i, m in enumerate(messages) if m.get("role") == "tool"]
-    if len(tool_idxs) <= keep_recent:
+    id_to_name = _tool_names_by_call_id(messages)
+    # Only REPLAYABLE-observation results are age-eligible; keep the last
+    # `keep_recent` of THOSE verbatim (counting non-replayable results toward
+    # the recency window would let a burst of writes push a still-needed read
+    # out of the kept set).
+    ageable_idxs = [
+        i for i, m in enumerate(messages)
+        if m.get("role") == "tool"
+        and _result_tool_name(m, id_to_name) in _REPLAYABLE_TOOLS
+    ]
+    if len(ageable_idxs) <= keep_recent:
         return messages
 
-    cutoff_idx = tool_idxs[-keep_recent]
+    cutoff_idx = ageable_idxs[-keep_recent]
     out: list[dict] = []
     for i, m in enumerate(messages):
         if i >= cutoff_idx or m.get("role") != "tool":
             out.append(m)
             continue
+        if _result_tool_name(m, id_to_name) not in _REPLAYABLE_TOOLS:
+            out.append(m)  # non-replayable (write/edit diff, etc.) — preserve
+            continue
         content = m.get("content") or ""
         if not isinstance(content, str) or len(content) < COMPACT_MIN_CONTENT_CHARS:
             out.append(m)
@@ -311,42 +370,42 @@ def _semantic_tool_summary(content: str) -> str:
 # this module for back-compat.
 
 def _redact_old_write_args(messages: list[dict]) -> list[dict]:
-    """Return a copy of `messages` with OLD write-tool arguments redacted.
-
-    The single biggest source of context bloat on coding-heavy sessions
-    is this: every write_file call carries its full `content` (often
-    hundreds of lines of code) in the assistant's tool_calls arguments.
-    That payload then sits in history forever and is re-shipped to the
-    model on every subsequent round — even though the file is already
-    on disk and a cheap read_file can reload it when needed.
-
-    This mirrors the agent `microcompact` pattern (see
-    `microCompactCore.ts:446`): keep the last N verbatim, replace older
-    ones with a short placeholder that tells the model "the payload is
-    gone but the file is still on disk — use read_file to see it."
-    Applied to write_file, edit_file, multi_edit since those are the
-    tools whose argument payloads dominate history size. Other tools
-    (bash, grep, read_file itself) have bounded or short arg payloads
-    so they don't need redaction — their BULK is in the tool_result
-    instead, which `_compact_old_tool_results` already handles.
-
-    Leaves the most-recent `REDACT_KEEP_RECENT_WRITES` calls untouched
-    so the model can reference the code it JUST wrote without a
-    read_file round-trip. Preserves tool_call id + name + `path` arg
-    (those are small and needed to reconcile the history chain). Only
-    strips the bulky payload field.
-
-    Returns a new list; never mutates the input.
-
-    Gated on `Feature.WRITE_ARG_REDACTION` — disabling returns the
-    input unchanged, which is what eval uses to A/B "how much bloat
-    is this preventing per session?"
+    """Pass-through: the model's OWN write/edit bodies are NEVER stripped.
+
+    History note (this used to strip them, and that was a bug)
+    ----------------------------------------------------------
+    This pass previously replaced older write_file `content` (and edit_file /
+    multi_edit anchors) in the assistant tool_calls with a "[REDACTED — file is
+    on disk, call read_file to reload]" stub, keeping only the last
+    `REDACT_KEEP_RECENT_WRITES` verbatim. The intent was to cut context bloat.
+
+    The real cost (observed in logs): after a build failure the model could no
+    longer SEE what it had written a few rounds earlier — the body was a stub —
+    so instead of a targeted fix it rewrote the whole file from scratch, over
+    and over (churn). What the model wrote is exactly what it needs to reason
+    about its own change; that record must stay in history.
+
+    The reference agents agree: claude-code's microCompact clears old tool
+    RESULTS but never the write BODIES in assistant messages; codex/opencode
+    likewise summarize whole turns wholesale only when over budget rather than
+    surgically deleting the code the model wrote. So this function no longer
+    strips anything. Context is bounded instead by:
+      * `_compact_old_tool_results` — ages only REPLAYABLE observation results
+        (read/grep/glob/list_files/bash), never write/edit diffs;
+      * `_redact_duplicate_reads` — collapses re-reads of the same path;
+      * `_microcompact_for_prompt_budget` / `_compact_messages` — summarize old
+        turns wholesale when the prompt genuinely approaches the window budget.
+
+    Kept as a named no-op (rather than deleted) so callers, telemetry, and the
+    A/B feature flag keep working. Still gated on `Feature.WRITE_ARG_REDACTION`.
     """
     from ..features import Feature, is_enabled
     if not is_enabled(Feature.WRITE_ARG_REDACTION):
         return messages
-
-    REDACT_TOOLS = {"write_file", "append_file", "edit_file", "multi_edit"}
+    # Never strip write/edit bodies — see docstring. Older-write redaction is
+    # intentionally disabled; the empty target set makes the rest of this
+    # function a structural no-op while preserving its shape for back-compat.
+    REDACT_TOOLS: set[str] = set()
 
     # Collect (outer_idx, tool_call_idx, tool_name) for every targeted call.
     targets: list[tuple[int, int, str]] = []

{localcode-0.3.19 → localcode-0.3.21}/src/localcode/agent/goal.py

@@ -102,14 +102,6 @@ def extract_feature_criteria(runtime, user_text: str, *, max_features: int = 12)
     return out
 
 
-_APP_BUILD_RE = re.compile(
-    r"\b(?:build|make|create|start|scaffold|help me build)\b.{0,80}\b"
-    r"(?:app|website|site|dashboard|frontend|web app|react app|streamlit|flask app)\b",
-    re.IGNORECASE | re.DOTALL,
-)
-_ASK_RE = re.compile(r"\b(?:what|which|where|when|why|how|explain|show)\b", re.IGNORECASE)
-_RUN_RE = re.compile(r"\b(?:run|start|launch|execute|open)\b", re.IGNORECASE)
-_EDIT_RE = re.compile(r"\b(?:fix|edit|change|update|modify|refactor|patch)\b", re.IGNORECASE)
 _SLUG_STOPWORDS = {
     "a",
     "an",
@@ -142,7 +134,6 @@ _SLUG_STOPWORDS = {
     "using",
     "via",
     "with",
-    "levels",
 }
 
 

{localcode-0.3.19 → localcode-0.3.21}/src/localcode/agent/loop.py

@@ -78,6 +78,9 @@ from .recovery import (
     detect_churn,
     churn_nudge_for,
     command_token,
+    detect_reject_reread_loop,
+    reject_reread_nudge,
+    todo_close_verification_suffix,
 )
 from .tool_orchestration import prefetch_parallel_tool_calls
 from .streaming import finish_thinking_display, stream_model_round
@@ -111,7 +114,6 @@ from .app_tasks import (
     ground_run_or_launch_text,
     has_launch_signal,
     has_runtime_verification_signal,
-    is_app_build_request,
     is_focused_blocking_question,
     looks_like_partial_handoff,
 )
@@ -404,15 +406,13 @@ def run_agent_loop(
         tools_called=tools_called,
     )
     hook_before_turn(_hook_state)
-    _app_build_request = is_app_build_request(user_text) or _goal_state.goal_type == "build_app"
     # Per-turn tool-output budget (in chars) scales with the model's REAL
     # context window instead of a fixed cap: allow tool results to fill up to
     # ~35% of the window before further output this turn is truncated. Dynamic
-    # per RAM/model — a 256K window keeps far more than a 64K one. The old fixed
-    # values (24K for app builds, 100K otherwise) starved big machines and,
-    # perversely, gave app builds — which read/write the MOST — the LEAST. The
-    # floor keeps small windows usable; within-turn overflow is still caught by
-    # the window-aware compaction pass at the top of each round.
+    # per RAM/model — a 256K window keeps far more than a 64K one. A single
+    # fixed cap starves big machines; the floor keeps small windows usable, and
+    # within-turn overflow is still caught by the window-aware compaction pass
+    # at the top of each round.
     try:
         _ctx_tokens_turn = int(app.engine._target_num_ctx())
     except Exception:
@@ -524,8 +524,37 @@ def run_agent_loop(
     # rounds (zero tools) reset the read-only streak. Resets to 0 the moment
     # a round changes a file or runs a build.
     _planning_streak = 0
-    # Build-verification gate: capped at ONE nudge per turn (loop-safe).
+    # Build-verification STOP gate: a true completion gate (claude-code
+    # query.ts stop-hook pattern). When the model tries to END a build_app turn
+    # that changed code, we run the project's real typecheck/test and, if it
+    # reports errors, inject them and FORCE another round instead of accepting
+    # "done". Bounded by _MAX_BUILD_VERIFY_RETRIES so a genuinely unfixable
+    # project can't spin forever; each retry RE-RUNS the check so the gate keeps
+    # holding until the project is clean or the bound is hit.
     _build_verify_nudges = 0
+    _MAX_BUILD_VERIFY_RETRIES = 2
+    # Reject → re-read → reject spin: ONE actionable redirect per turn
+    # (recovery.detect_reject_reread_loop, recomputed from the transcript).
+    _reject_reread_nudge_done = False
+    # Last synthetic-nudge kind we injected, so the recovery ladder never fires
+    # the SAME nag twice in a row (claude-code attachments.ts two-and-threshold
+    # discipline). Routed through `_append_nudge` below.
+    _last_nudge_kind = ""
+
+    def _append_nudge(content: str, kind: str, *, ephemeral: bool = True) -> bool:
+        """Append a synthetic SYSTEM nudge unless the SAME `kind` was the
+        immediately-previous nudge (never the same nag twice running — the
+        two-and-threshold discipline). Records the injected index for
+        end-of-turn ephemeral cleanup. Returns True when it actually appended.
+        """
+        nonlocal _last_nudge_kind
+        if kind and kind == _last_nudge_kind:
+            return False
+        messages.append({"role": "user", "content": content})
+        if ephemeral:
+            _ephemeral_nudge_indices.append(len(messages) - 1)
+        _last_nudge_kind = kind
+        return True
     # Cross-round repeated-call breaker: count identical (tool, args) calls
     # across the WHOLE turn (the in-round breaker only catches one round).
     # NUDGE-only — never withholds a tool result (avoids the read-dedup-stub
@@ -1264,8 +1293,13 @@ def run_agent_loop(
                     f"continue… (auto-retry {_empty_rounds_this_turn}/"
                     f"{_MAX_EMPTY_ROUND_RETRIES})"
                 )
-                messages.append({"role": "user", "content": nudge_for(stall)})
-                _ephemeral_nudge_indices.append(len(messages) - 1)
+                # Route through the guard so the SAME stall nudge never fires
+                # two rounds running (two-and-threshold discipline). If it's
+                # suppressed we still continue — the retry counter advanced and
+                # the assistant's dead "about to act" message was already
+                # dropped, so the model gets another clean shot without the
+                # self-conditioning duplicate nag.
+                _append_nudge(nudge_for(stall), kind=f"stall:{stall.name}")
                 continue  # next round of the main loop
             else:
                 out.print_info(
@@ -1298,30 +1332,38 @@ def run_agent_loop(
             # permission question, the user gets to answer — the runtime
             # does not silently force a retry.
             _blocking_question = is_focused_blocking_question(content)
-            # ── Build-verification gate ──
-            # The model wants to finish a build_app turn, but it changed CODE
-            # and never built/typechecked/tested or ran it. Nudge it ONCE to
-            # compile + fix before finishing. STRICTLY scoped to avoid the
-            # 2026-04-29 paraphrase-loop regression: build_app goal ONLY (never
-            # Q&A), not a blocking question, never deletes the assistant answer,
-            # capped at one nudge per turn. Mirrors the proven stall-nudge
-            # pattern (append user message + continue).
+            # ── Build-verification STOP gate (claude-code query.ts stop-hook) ──
+            # The model wants to END a build_app turn that changed CODE. This is
+            # a TRUE completion gate, not a one-shot nudge: we RUN the project's
+            # own typecheck/test ourselves and, if it reports errors, inject them
+            # and FORCE another round — the model cannot declare "done" while the
+            # gate is red. Each completion attempt RE-RUNS the check, so the gate
+            # keeps holding until the project is clean or _MAX_BUILD_VERIFY_RETRIES
+            # is hit (a genuinely unfixable project can't spin forever).
+            #
+            # NOTE: gated on build_app, which `infer_goal_state` (now generalist)
+            # never sets — so this stop-gate is currently DORMANT. That's
+            # intentional for 0.3.20: making it general ("any code-changing turn
+            # + a checker") fires a full project typecheck on every one-line edit,
+            # which is too aggressive and slow. A proper general trigger (fire on
+            # a multi-file / new-file BUILD completion, not a small edit) is a
+            # follow-up. Left dormant rather than shipped half-tuned.
             if (
                 not _blocking_question
                 and _goal_state.goal_type == "build_app"
-                and _build_verify_nudges < 1
+                and _build_verify_nudges < _MAX_BUILD_VERIFY_RETRIES
                 and _is_enabled(Feature.AUTO_NUDGE_RECOVERY)
                 and _changed_code_files(changed_files)
-                and not has_runtime_verification_signal(bash_history)
-                and not ran_build_or_test(bash_history)
             ):
-                _build_verify_nudges += 1
+                _self_verified = (
+                    has_runtime_verification_signal(bash_history)
+                    or ran_build_or_test(bash_history)
+                )
                 # TIER-2 VERIFICATION: don't just NUDGE the model to typecheck
                 # (a small model skips it or mishandles output) — RUN the
                 # project's real typecheck/lint ourselves and feed the concrete
                 # errors back. Catches semantic errors (wrong names, missing
-                # imports) the per-write syntax check can't. Light: once per
-                # turn, at completion. See tools.project_check.
+                # imports) the per-write syntax check can't. See project_check.
                 _proj_errors = None
                 try:
                     from ..tools.project_check import run_project_check
@@ -1331,11 +1373,19 @@ def run_agent_loop(
                     _proj_errors = None
                 try:
                     from ..events import emit as _emit_bg
-                    _emit_bg("auto_nudge", signal="build_unverified",
-                             round_idx=round_num, had_errors=bool(_proj_errors))
+                    _emit_bg("auto_nudge", signal="build_verify_gate",
+                             round_idx=round_num, attempt=_build_verify_nudges,
+                             had_errors=bool(_proj_errors),
+                             self_verified=bool(_self_verified))
                 except Exception:
                     pass
                 if _proj_errors:
+                    # STOP: cannot finish while the gate is red. Errors are fresh
+                    # actionable feedback (they change as the model fixes them),
+                    # so this is NOT routed through the "not twice in a row" nag
+                    # guard — but we record the kind so a following reminder-style
+                    # nudge doesn't stack on top of it.
+                    _build_verify_nudges += 1
                     out.print_info("Typecheck found errors — sending them back to fix.")
                     messages.append({"role": "user", "content": (
                         "SYSTEM: the project's typecheck/build was run for you and "
@@ -1343,17 +1393,25 @@ def run_agent_loop(
                         "then finish. Do not claim it works until these are gone:\n\n"
                         + _proj_errors
                     )})
-                else:
-                    # No checker available, or it passed — fall back to advising.
+                    _ephemeral_nudge_indices.append(len(messages) - 1)
+                    _last_nudge_kind = "build_verify_errors"
+                    continue  # don't accept completion — the gate is red
+                if not _self_verified and _build_verify_nudges < 1:
+                    # Gate is clean (checker passed OR none configured) AND the
+                    # model never ran a build/test itself — advise ONCE to verify.
+                    # This one IS a recurring-style nag → routed through the guard.
+                    _build_verify_nudges += 1
                     out.print_info("Changed code but never built/ran it — nudging to verify.")
-                    messages.append({"role": "user", "content": (
+                    if _append_nudge(
                         "SYSTEM: You changed code but never built, type-checked, or ran "
                         "it. Run the project's build/typecheck (npm run build / npx tsc "
                         "--noEmit for TS; tests or an import smoke-check for Python), fix "
-                        "every error, then finish. Don't claim it works without building."
-                    )})
-                _ephemeral_nudge_indices.append(len(messages) - 1)
-                continue  # don't accept completion — let it fix first
+                        "every error, then finish. Don't claim it works without building.",
+                        kind="build_verify_advise",
+                    ):
+                        continue  # let it verify before finishing
+                # else: gate clean and either self-verified or already advised →
+                # fall through and accept completion.
             if _goal_state.goal_type == "run_or_launch":
                 _task_port = int(getattr(_task_state, "active_port", 0) or 0)
                 content = ground_run_or_launch_text(content, _task_port)
@@ -1552,8 +1610,8 @@ def run_agent_loop(
             # Same-call 3× guard for tools without their own dedup
             # (bash / web_fetch / web_search / launch_app). Took the
             # place of the broader exact-repeat counter that was retired
-            # 2026-04-26 — re-added narrowly after a "how hot in france"
-            # turn fired the same `curl wttr.in/Paris?format=…` 4× in a
+            # 2026-04-26 — re-added narrowly after an info-fetch turn
+            # fired the same read-only `curl` command 4× in a
             # row. dedup_stub wins ties so list_files/glob/grep keep
             # their existing message.
             if _dedup_stub is None:
@@ -1881,6 +1939,30 @@ def run_agent_loop(
                 _stub_chars = max(500, int(_ctx_tokens_turn * 3.5 * 0.01)) if _ctx_tokens_turn else 500
                 tool_result = tool_result[:_stub_chars] + "\n[Truncated — context budget exceeded this turn]"
 
+            # ── Todo-close verification nudge (claude-code TodoWriteTool) ──
+            # When the model just marked a 3+ item todo list fully done and none
+            # of the items was a verification step, append a one-line "verify
+            # before your final summary" reminder that RIDES ON this tool result
+            # — no extra round. Appended after truncation so the short reminder
+            # can't be clipped. General + cheap (pure fn of the todos it sent).
+            if tool_name == "todo_write" and isinstance(args, dict):
+                try:
+                    _todo_suffix = todo_close_verification_suffix(args.get("todos"))
+                except Exception:
+                    _todo_suffix = ""
+                if _todo_suffix:
+                    tool_result = f"{tool_result}{_todo_suffix}"
+                    try:
+                        from ..events import emit as _emit_todo_verify
+                        _emit_todo_verify(
+                            "todo_close_verify_nudge",
+                            turn_id=_turn_id,
+                            round_idx=round_num,
+                            item_count=len(args.get("todos") or []),
+                        )
+                    except Exception:
+                        pass
+
             # Add to history
             messages.append({
                 "role": "tool",
@@ -2034,6 +2116,39 @@ def run_agent_loop(
                 )
                 messages.append({"role": "user", "content": churn_nudge_for(_churn)})
                 _ephemeral_nudge_indices.append(len(messages) - 1)
+                _last_nudge_kind = "churn"
+
+        # ── Reject → re-read → reject recovery rung (bounded, single-shot) ──
+        # The remaining log loop the other detectors miss: a mutation keeps
+        # coming back REJECTED (dedup / "already modified" / old_string-not-found)
+        # and the model reacts by re-reading the file and retrying the same
+        # shape. detect_reject_reread_loop RECOMPUTES the signal from the
+        # transcript tail (survives compaction). We give ONE actionable redirect
+        # per turn, then stop nagging (the guard boolean). Composes with the
+        # existing breakers: gated so it won't fire in a round another nudge
+        # already fired, and `_append_nudge` blocks the same nag twice running.
+        if (
+            not _reject_reread_nudge_done
+            and not _churn_nudge_done
+            and not _spin_nudge_done
+            and not _xround_repeat_nudge_done
+            and not _hard_stop_nudge_fired
+            and _is_enabled(Feature.AUTO_NUDGE_RECOVERY)
+        ):
+            _rr_count = detect_reject_reread_loop(messages)
+            if _rr_count is not None:
+                if _append_nudge(reject_reread_nudge(), kind="reject_reread"):
+                    _reject_reread_nudge_done = True
+                    out.print_info(
+                        "Detected a reject → re-read loop — giving it one "
+                        "targeted redirect."
+                    )
+                    try:
+                        from ..events import emit as _emit_rr
+                        _emit_rr("auto_nudge", signal="reject_reread_loop",
+                                 count=_rr_count, round_idx=round_num)
+                    except Exception:
+                        pass
 
         # Break outer loop if loop was detected
         if loop_detected:

{localcode-0.3.19 → localcode-0.3.21}/src/localcode/agent/prompts.py

@@ -44,7 +44,7 @@ You are LocalCode, a coding agent running locally on the user's machine with ful
 Top rules (most important first):
 1. ACT, DON'T NARRATE. If you say "let me read/fix/write X", the tool call that does it MUST come next, in the same turn. Never end a turn on a statement of intent. At most one short sentence of preamble per tool call.
 2. FINISH THE JOB. Cover every requirement the user named. Write complete, runnable code — no TODOs, stubs, placeholders, or "should I do X next?". If a piece is too big for one call, split it across calls; never drop it.
-3. MATCH SCOPE. Answer plain questions plainly; build only what was asked. Don't write a script when one bash line does it.
+3. MATCH SCOPE & BE TERSE. Answer plain questions plainly and briefly — a sentence or two, no preamble ("Here is…") or postamble ("Let me know if…"); build only what was asked. Terseness is about your PROSE, not the code — write complete code, few words around it.
 4. DON'T REPEAT WORK. Don't re-read a file or re-run a command you already did — the result is still above. After a tool result, continue from where you left off; don't restate the plan.
 5. DON'T INVENT. If you don't recognize a term, library, or command, say so — never guess a plausible meaning. Search the web before asserting facts; if results are empty, say that.
 
@@ -54,10 +54,9 @@ Plan & tools:
 - For files and dirs use list_files/read_file/write_file/edit_file — NOT bash (`ls`, `cat`, `cat >`, `>`). bash is only for running commands (npm, git, build, test).
 - edit_file for existing files: anchor `old_string` on 2–4 adjacent lines (matching is whitespace-tolerant; the leading `<n>\\t` from read_file is stripped for you). write_file to create or fully rewrite.
 - On a tool error, read it, fix the specific cause, and retry — don't give up after one failure, and don't repeat the same failing call.
-- New project → prefer a small multi-file layout with a thin entrypoint. Write code valid for the file's real language and match the project's existing conventions. Put source under `src/`, config at the repo root.
-- Define the shared types / data model FIRST, then write everything against them. Don't write pages/UI before their types exist — naming mismatches force a full rewrite later.
-- Don't invent dependencies: before importing a library confirm it's in package.json (or requirements.txt/Cargo.toml) or a neighboring file; when installing, don't pin a guessed version — `npm install <pkg>` lets the resolver pick a real one.
-- Never assume a library's API. Before using a package's exports, types, or signatures, verify them — read its files in node_modules, check how neighboring files use it, or web_fetch its docs. Don't guess names. Port known algorithms from the real reference (web_fetch), not from memory.
+- New project → prefer a small multi-file layout with a thin entrypoint. Write code valid for the file's real language and match the project's existing conventions. Keep source in the language's conventional directory (not dumped in the repo root).
+- Don't invent dependencies: before importing a library confirm it's in the project's manifest (package.json / requirements.txt / Cargo.toml / go.mod) or a neighboring file; when installing, don't pin a guessed version — let the package manager's resolver pick a real one.
+- Never assume a library's API. Before using a package's exports, types, or signatures, verify them — read its installed source, check how neighboring files use it, or web_fetch its docs. Don't guess names. Implementing from a spec or reference? Work from the real source (web_fetch it), not memory.
 
 Runtime facts:
 - bash returns an exit code; non-zero = failure. Background long-running commands (`cmd &`) so bash returns.
@@ -135,10 +134,8 @@ def model_identity_line(model: str) -> str:
         f"the work: take the next action directly. Only state your name if the "
         f"user explicitly asks who you are. "
         f"The model currently powering you is \"{friendly}\". Report it as EXACTLY "
-        f"\"{friendly}\" when the user asks which model/version/quant you are, or "
-        f"when the task asks you to name a file/folder/project after your model — "
-        f"in that case use \"{friendly}\" as the name and create it. Never say you "
-        f"are unsure and never name a different model or provider.\n"
+        f"\"{friendly}\" when the user asks which model/version/quant you are. "
+        f"Never say you are unsure and never name a different model or provider.\n"
     )