chad-code 1.0.1__tar.gz → 1.0.3__tar.gz

{chad_code-1.0.1/src/chad_code.egg-info → chad_code-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chad-code
-Version: 1.0.1
+Version: 1.0.3
 Summary: Local MLX-backed, Claude-Code-style coding agent (Apple Silicon, Ornith 35B/9B)
 License-Expression: MIT
 Project-URL: Repository, https://github.com/nathansutton/chad
@@ -39,7 +39,7 @@ Dynamic: license-file
 
 [![tests](https://github.com/nathansutton/chad/actions/workflows/tests.yml/badge.svg)](https://github.com/nathansutton/chad/actions/workflows/tests.yml)
 
-<img src="docs/tbench-size-vs-score.png" width="840" alt="Terminal-Bench 2.0: accuracy vs. model size. chad + Ornith (a 35B MoE) lands on the Claude Sonnet 4.5 line, matching open models many times its size and standing alone in the laptop-class ≤40B band.">
+<img src="docs/tbench-size-vs-score.png" width="840" alt="Terminal-Bench 2.1: accuracy vs. cost per run. Every verified entry is a proprietary frontier model in a datacenter, costing $130–$2,000 per run. chad + Ornith (a 35B MoE) clears 57% on an Apple Silicon laptop for the electricity — the only no-API-cost point on the board.">
 
 > Claude can do anything, for anyone, anywhere. chad does one thing. 🗿
 > *Coding under supervision.*
@@ -86,20 +86,20 @@ instrument:
 > Real session, unedited (cold model load cut): a local 35B reasons through the failure,
 > edits the file, reruns the tests, confirms green.
 
-## Sonnet on your laptop
+## Frontier scores, laptop cost
 
 The exam is [Terminal-Bench](https://www.tbench.ai/leaderboard), the standard benchmark for
-CLI coding agents. chad won't top it — the A students are frontier models in datacenters.
-The number worth looking at is **how much capability chad wrings out of 35B parameters**:
-on Terminal-Bench 2.1, chad + Ornith lands around the **Claude Sonnet 4.5** line, matching
-open models many times its size and beating every open model in its own weight class by a
-wide margin. On a laptop, *capability per parameter* is the axis you actually compete on —
-and that's where chad + Ornith is out on the frontier alone.
-
-> **Placeholder number** — the full verified run is still in flight (`≈50%`, k=1). The whole
-> benchmark is **publicly reproducible from a Mac**: the exact Harbor adapter, the runner,
-> and the recipe live in [`benchmarks/tb2/`](benchmarks/tb2/README.md). Check it, don't
-> trust it.
+CLI coding agents. chad won't top it — every verified entry on Terminal-Bench 2.1 is a
+frontier model in a datacenter, scoring 59–84%. The number worth looking at is what that
+capability **costs**: the paid field spends **$130–$2,000 in API fees per run**. chad +
+Ornith clears **57%** on an Apple Silicon laptop, for the electricity — no API, no tokens,
+no datacenter. On a laptop, *capability per dollar* is the axis you actually compete on, and
+chad is the only point on the board that runs there.
+
+> **Provisional number** — `57%` (51/89, k=1, self-run, not yet leaderboard-verified). The
+> whole benchmark is **publicly reproducible from a Mac**: the exact Harbor adapter, the
+> runner, and the recipe live in [`benchmarks/tb2/`](benchmarks/tb2/README.md). Check it,
+> don't trust it.
 
 ## The bet: at this end of the report card, the harness beats the model
 
@@ -214,7 +214,7 @@ Both are covered in full in the [Configuration reference](docs/configuration.md)
   cache, the trimmable/append-only trade, and the ideas borrowed from other agents.
 - **[Throughput & performance](docs/benchmarks.md)** — prefill / decode / warm-step numbers
   you can reproduce with `chad-bench`.
-- **[Terminal-Bench 2.0 reproduction](benchmarks/tb2/README.md)** — the exact Harbor adapter
+- **[Terminal-Bench 2.1 reproduction](benchmarks/tb2/README.md)** — the exact Harbor adapter
   and runner behind the chart; serve Ornith yourself and check the number.
 - **[Configuration reference](docs/configuration.md)** — Agent Skills, MCP servers, the
   context window, every environment variable, and the safety opt-outs.

{chad_code-1.0.1 → chad_code-1.0.3}/README.md

@@ -2,7 +2,7 @@
 
 [![tests](https://github.com/nathansutton/chad/actions/workflows/tests.yml/badge.svg)](https://github.com/nathansutton/chad/actions/workflows/tests.yml)
 
-<img src="docs/tbench-size-vs-score.png" width="840" alt="Terminal-Bench 2.0: accuracy vs. model size. chad + Ornith (a 35B MoE) lands on the Claude Sonnet 4.5 line, matching open models many times its size and standing alone in the laptop-class ≤40B band.">
+<img src="docs/tbench-size-vs-score.png" width="840" alt="Terminal-Bench 2.1: accuracy vs. cost per run. Every verified entry is a proprietary frontier model in a datacenter, costing $130–$2,000 per run. chad + Ornith (a 35B MoE) clears 57% on an Apple Silicon laptop for the electricity — the only no-API-cost point on the board.">
 
 > Claude can do anything, for anyone, anywhere. chad does one thing. 🗿
 > *Coding under supervision.*
@@ -49,20 +49,20 @@ instrument:
 > Real session, unedited (cold model load cut): a local 35B reasons through the failure,
 > edits the file, reruns the tests, confirms green.
 
-## Sonnet on your laptop
+## Frontier scores, laptop cost
 
 The exam is [Terminal-Bench](https://www.tbench.ai/leaderboard), the standard benchmark for
-CLI coding agents. chad won't top it — the A students are frontier models in datacenters.
-The number worth looking at is **how much capability chad wrings out of 35B parameters**:
-on Terminal-Bench 2.1, chad + Ornith lands around the **Claude Sonnet 4.5** line, matching
-open models many times its size and beating every open model in its own weight class by a
-wide margin. On a laptop, *capability per parameter* is the axis you actually compete on —
-and that's where chad + Ornith is out on the frontier alone.
-
-> **Placeholder number** — the full verified run is still in flight (`≈50%`, k=1). The whole
-> benchmark is **publicly reproducible from a Mac**: the exact Harbor adapter, the runner,
-> and the recipe live in [`benchmarks/tb2/`](benchmarks/tb2/README.md). Check it, don't
-> trust it.
+CLI coding agents. chad won't top it — every verified entry on Terminal-Bench 2.1 is a
+frontier model in a datacenter, scoring 59–84%. The number worth looking at is what that
+capability **costs**: the paid field spends **$130–$2,000 in API fees per run**. chad +
+Ornith clears **57%** on an Apple Silicon laptop, for the electricity — no API, no tokens,
+no datacenter. On a laptop, *capability per dollar* is the axis you actually compete on, and
+chad is the only point on the board that runs there.
+
+> **Provisional number** — `57%` (51/89, k=1, self-run, not yet leaderboard-verified). The
+> whole benchmark is **publicly reproducible from a Mac**: the exact Harbor adapter, the
+> runner, and the recipe live in [`benchmarks/tb2/`](benchmarks/tb2/README.md). Check it,
+> don't trust it.
 
 ## The bet: at this end of the report card, the harness beats the model
 
@@ -177,7 +177,7 @@ Both are covered in full in the [Configuration reference](docs/configuration.md)
   cache, the trimmable/append-only trade, and the ideas borrowed from other agents.
 - **[Throughput & performance](docs/benchmarks.md)** — prefill / decode / warm-step numbers
   you can reproduce with `chad-bench`.
-- **[Terminal-Bench 2.0 reproduction](benchmarks/tb2/README.md)** — the exact Harbor adapter
+- **[Terminal-Bench 2.1 reproduction](benchmarks/tb2/README.md)** — the exact Harbor adapter
   and runner behind the chart; serve Ornith yourself and check the number.
 - **[Configuration reference](docs/configuration.md)** — Agent Skills, MCP servers, the
   context window, every environment variable, and the safety opt-outs.

{chad_code-1.0.1 → chad_code-1.0.3}/pyproject.toml

@@ -4,7 +4,7 @@
 # import name, and command name are independent. `uvx chad-code` runs the alias
 # script added under [project.scripts].
 name = "chad-code"
-version = "1.0.1"
+version = "1.0.3"
 description = "Local MLX-backed, Claude-Code-style coding agent (Apple Silicon, Ornith 35B/9B)"
 readme = "README.md"
 license = "MIT"

{chad_code-1.0.1 → chad_code-1.0.3}/src/chad/__init__.py

@@ -4,4 +4,4 @@ A flat collection of cooperating modules behind one console script (``chad``):
 the inference engine, the tool layer, the agent loop, and the terminal UI.
 """
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"

{chad_code-1.0.1 → chad_code-1.0.3}/src/chad/agent.py

@@ -786,6 +786,13 @@ class Agent:
         gate_nudges = 0       # times the investigation->edit gate fired this turn
         subagent_sigs = set() # (description, prompt) of sub-agents already spawned this turn
         truncation_nudges = 0  # times we pushed past a token-cap truncation this turn
+        garble_nudges = 0  # malformed-tool-call re-nudges (own counter, so a step-0
+                           # cap-hit can't spend the garble recovery budget)
+        consecutive_garbles = 0  # back-to-back garbled steps (drives exemplar + scrub)
+        last_garble_idx = None   # self.messages index of the previous garbled assistant
+                                 # message (scrubbed if the next step garbles too)
+        done_audit_bounces = 0   # total audit bounces this turn (hard cap 2)
+        audit_absent_list = []   # task-named paths the FIRST audit stat'ed as absent
         landing_nudges = 0  # one-shot "you're out of steps, land the edit" near the cap
         consecutive_failed_bash = 0  # back-to-back errored bash with no edit (thrash)
         thrash_nudges = 0
@@ -807,12 +814,18 @@ class Agent:
         # Turn-level cumulative think budget: distinct from self.think_tokens
         # (lifetime across the whole Agent instance, used for cross-turn telemetry) — this
         # is THIS turn's spend, reset every run_turn call, checked against a wall- and
-        # decode-speed-aware budget. turn_think_exhausted is a PERSISTENT latch (unlike
-        # capped_stall_streak's one-shot no_think_next above): once it fires, every
-        # remaining step in the turn decodes with thinking off.
+        # decode-speed-aware budget. turn_think_exhausted latches the once-only
+        # log/steer; past it, no-think steps are paid on a duty cycle
+        # (guardrails.turn_think_throttle) rather than muting the rest of the turn —
+        # the blanket mute regressed run1 passes with garbled no-think tails (plan 107).
+        # landing_no_think is the 103 landing's own unconditional latch: once the hard
+        # wrap-up fires, the landing and everything after it stay no-think regardless.
         turn_think_tokens = 0
         turn_think_half_fired = False
         turn_think_exhausted = False
+        turn_think_nothink_paid = 0
+        turn_think_budget_now = 0
+        landing_no_think = False
         # Runaway-turn governor state. turn_start drives the optional wall
         # budget; gov_band is the highest budget checkpoint already evaluated; gov_progress
         # tracks whether a change landed+verified within the CURRENT band (resets each time
@@ -845,6 +858,12 @@ class Agent:
         # where it also selects the plan-mode prefix.)
         action_task = self.mode != "plan" and _intent["action"]
         read_only_intent = _intent["read_only"]
+        # Run-task intent (start/boot/serve/… — system-state imperatives with no file
+        # deliverable): arms the anti-bail nudges alongside action_task but is kept OUT
+        # of the no-empty-diff done gates below, which demand a landed edit a run task
+        # legitimately never makes (plan 107 follow-up: qemu-startup classified as
+        # neither, so a prose give-up with 81% of the wall left took the weakest path).
+        run_task = self.mode != "plan" and _intent.get("run", False)
         # Progress-aware step cap (see guardrails.extend_step_cap): max_steps is the
         # WINDOW size, not a hard kill. A window that landed+verified a change earns
         # another window (warm cache — no re-prefill, unlike a governor rollover); a
@@ -963,9 +982,19 @@ class Agent:
             # <think> off so the model must act, then the flag clears and thinking restores.
             # Consumes the one-shot here; the render/decode/accounting below all key off
             # `step_thinking` rather than self.thinking for exactly this step.
-            # Turn-level think budget: once exhausted, thinking stays off for
-            # every remaining step — a persistent override, unlike no_think_next below.
-            step_thinking = self.thinking and not turn_think_exhausted
+            # Turn-level think budget: past exhaustion, forced no-think steps are
+            # paid on a duty cycle (one per TURN_THINK_REARM_TOK further think tokens)
+            # so thinking RESTORES once the model stops over-spending — a blanket
+            # rest-of-turn mute regressed run1 passes (plan 107 F1). The 103 landing's
+            # landing_no_think stays unconditional.
+            _tt_throttled = (turn_think_exhausted
+                             and guardrails.turn_think_throttle(
+                                 turn_think_tokens, turn_think_budget_now,
+                                 turn_think_nothink_paid))
+            if _tt_throttled:
+                turn_think_nothink_paid += 1
+            step_thinking = (self.thinking and not landing_no_think
+                             and not _tt_throttled)
             if no_think_next:
                 no_think_next = False
                 capped_stall_streak = 0
@@ -1203,9 +1232,15 @@ class Agent:
             # turns (a Q&A turn shouldn't be pushed to "act now") and without a configured
             # wall budget (interactive/unmetered runs, like wrapup_window above).
             turn_think_tokens += _think_delta
-            if (self._turn_budget_s and self.mode != "plan" and not read_only_intent
+            # Inert below TURN_THINK_MIN_WALL_S: a short auto-continue tail clamps to
+            # the LO budget and half-fires on its first step, churning against
+            # hard_wrapup's landing (plan 107 F2 — the regex-log relaunch signature).
+            if (self._turn_budget_s
+                    and self._turn_budget_s >= guardrails.TURN_THINK_MIN_WALL_S
+                    and self.mode != "plan" and not read_only_intent
                     and levers.enabled("turn_think_budget")):
                 _tt_budget = guardrails.turn_think_budget(self._turn_budget_s, self.tok_per_s)
+                turn_think_budget_now = _tt_budget
                 _tt_decision, turn_think_half_fired, turn_think_exhausted = (
                     guardrails.turn_think_budget_check(
                         turn_think_tokens, _tt_budget,
@@ -1217,10 +1252,11 @@ class Agent:
                                           "content": guardrails.TURN_THINK_BUDGET_STEER})
                 elif _tt_decision == "exhausted":
                     log.info("THINK-BUDGET exhausted at step %d: %d/%d cumulative think "
-                             "tok this turn — no-think for the rest of the turn", step,
-                             turn_think_tokens, _tt_budget)
+                             "tok this turn — throttling <think> (one action step per "
+                             "%d further think tok)", step, turn_think_tokens,
+                             _tt_budget, guardrails.TURN_THINK_REARM_TOK)
                     self._emit("info", "  [reasoning budget exhausted for this turn — "
-                                       "acting without further <think> for the rest of it]")
+                                       "throttling further <think>]")
 
             log.info("step %d: %d tok @ %.1f tok/s | prefill %d new + %d cached | "
                      "accept %.2f", step, stats.generated_tokens, stats.tok_per_s,
@@ -1277,7 +1313,7 @@ class Agent:
             # above) with its tokens in the KV cache. Force ONE time-boxed, no-think
             # landing turn so the model writes its best artifacts to the exact paths before
             # the harness kills the turn at the wall — instead of dying mid-token with
-            # nothing landed. turn_think_exhausted makes the landing (and any step after it)
+            # nothing landed. landing_no_think makes the landing (and any step after it)
             # no-think so it can't re-open a spiral; the latch disarms _deadline_stop, so
             # the landing generation runs to its token box, not another abort. deadline_fired
             # is exclusive with rep_fired / the think-cap below (it is checked first in
@@ -1286,7 +1322,7 @@ class Agent:
             # there is rarely one, and partial-tool-call surgery is not worth its risk here.
             if deadline_fired[0] and not hard_wrapup_fired:
                 hard_wrapup_fired = True
-                turn_think_exhausted = True
+                landing_no_think = True
                 _remaining = self._turn_budget_s - (time.monotonic() - turn_start)
                 log.info("HARD-WRAPUP abort at step %d: %.0fs left, gen was %d tok",
                          step, _remaining, stats.generated_tokens)
@@ -1371,12 +1407,33 @@ class Agent:
                 _stripped_for_markers = strip_think(text)
                 garbled = ("<tool_call>" in _stripped_for_markers
                            or "</function>" in _stripped_for_markers
-                           or "<function=" in _stripped_for_markers)
+                           or "<function=" in _stripped_for_markers
+                           or _has_open_tool_call(text))
+                if garbled:
+                    consecutive_garbles += 1
+                    # From the 2nd consecutive garble, scrub the PREVIOUS garbled
+                    # assistant body: the wrong dialect must not stay in context as a
+                    # few-shot example (repeated garbles in a row each condition on the
+                    # last). Costs one prefix-cache invalidation on this rare path.
+                    if (levers.enabled("garble_never_final")
+                            and consecutive_garbles >= 2 and last_garble_idx is not None):
+                        self.messages[last_garble_idx]["content"] = \
+                            guardrails.GARBLE_SCRUBBED
+                        log.info("GARBLE scrub at step %d: previous garbled message "
+                                 "body removed from context (consecutive=%d)",
+                                 step, consecutive_garbles)
+                    last_garble_idx = len(self.messages) - 1
+                else:
+                    consecutive_garbles = 0
                 kind, nudge = guardrails.nudge_for_no_calls(
                     text, hit_cap, made_edit, unverified_edit, read_only_intent,
-                    action_task, truncation_nudges, answer_nudges, verify_nudges,
-                    _has_open_tool_call(text), garbled_call=garbled)
-                if kind == "truncated":
+                    action_task or run_task, truncation_nudges, answer_nudges,
+                    verify_nudges, _has_open_tool_call(text), garbled_call=garbled,
+                    garble_nudges=garble_nudges,
+                    consecutive_garbles=consecutive_garbles)
+                if kind == "garble":
+                    garble_nudges += 1
+                elif kind == "truncated":
                     truncation_nudges += 1
                 elif kind == "no-edit":
                     answer_nudges += 1
@@ -1384,9 +1441,25 @@ class Agent:
                     verify_nudges += 1
                 if nudge:
                     log.info("END-ANSWER rejected step %d: %s (hit_cap=%s, has_code=%s, "
-                             "action_task=%s)", step, kind, hit_cap, has_code, action_task)
+                             "action_task=%s, run_task=%s)", step, kind, hit_cap,
+                             has_code, action_task, run_task)
                     self.messages.append({"role": "tool", "name": "edit", "content": nudge})
                     continue
+                # Invariant: a step whose text contains tool-call markers is NEVER a
+                # final answer — the model was trying to act, not to finish. With the
+                # nudge budget spent, hard-stop with a banked note instead of accepting
+                # the garble (otherwise a run of garbles can burn the shared counter and
+                # the audit latch, and the last one ships as the answer with most of the
+                # wall budget still unspent).
+                if garbled and levers.enabled("garble_never_final"):
+                    self.budget_note = guardrails.progress_note(self.messages)
+                    log.info("END step %d: GARBLE hard-stop (%d garble nudges spent) — "
+                             "a garbled tool call is never a final answer",
+                             step, garble_nudges)
+                    self._emit("info", "  [turn stopped: repeated malformed tool calls "
+                                       "— progress note banked; say 'continue' to retry]")
+                    return ("[stopped: the model kept emitting malformed tool calls "
+                            "— say 'continue' to resume]")
                 # Iter-3 did-nothing gate: in auto/headless mode (every benchmark run), a
                 # turn that ends having executed ZERO real tools is never a legitimate
                 # completion — the keyword intent classifier misses tasks like "extract the
@@ -1405,7 +1478,9 @@ class Agent:
                     # and end as a hard stop, so --auto-continue (headless) or the
                     # user's 'continue' (TUI) relaunches a fresh attempt with the
                     # note instead of silently shipping nothing.
-                    self.budget_note = guardrails.progress_note(self.messages)
+                    self.budget_note = guardrails.progress_note(
+                        self.messages,
+                        rejected_claim=strip_think(text).strip())
                     log.info("END step %d: FINAL ANSWER blocked by no-empty-diff gate "
                              "(made_edit=%s, unverified_edit=%s) — progress note banked",
                              step, made_edit, unverified_edit)
@@ -1433,6 +1508,8 @@ class Agent:
                     })
                     if audit:
                         done_audit_fired = True
+                        done_audit_bounces += 1
+                        audit_absent_list = guardrails.audit_absent_paths(audit_task)
                         _runway = ((self._turn_budget_s
                                     - (time.monotonic() - turn_start))
                                    if self._turn_budget_s else float("inf"))
@@ -1442,6 +1519,26 @@ class Agent:
                         self.messages.append({"role": "tool", "name": "edit",
                                               "content": audit})
                         continue
+                # Absent-path re-bounce: the first audit stat'ed task-named paths as
+                # ABSENT and promised acceptance anyway; if they are STILL absent with
+                # runway to spare, bounce one final time (cap 2/turn) — otherwise a
+                # task-named deliverable the audit already flagged absent can go
+                # unwritten and the accept still goes through.
+                if self.mode != "plan" and not self._subagent \
+                        and done_audit_fired and done_audit_bounces < 2 \
+                        and audit_absent_list:
+                    _runway = ((self._turn_budget_s
+                                - (time.monotonic() - turn_start))
+                               if self._turn_budget_s else None)
+                    rebounce = guardrails.audit_rebounce(audit_absent_list, _runway)
+                    if rebounce:
+                        done_audit_bounces += 1
+                        audit_absent_list = []
+                        log.info("DONE-AUDIT rebounce (final-answer): still-absent "
+                                 "task paths, runway=%s", _runway)
+                        self.messages.append({"role": "tool", "name": "edit",
+                                              "content": rebounce})
+                        continue
                 log.info("END step %d: model produced a FINAL ANSWER, no tool calls "
                          "(did_work=%s, made_edit=%s, unverified_edit=%s)",
                          step, did_work, made_edit, unverified_edit)
@@ -1451,6 +1548,8 @@ class Agent:
             # The step acted — the spiral broke on its own, so clear the no-think escalation
             # streak: escalation is only for consecutive capped/salvaged stalls.
             capped_stall_streak = 0
+            consecutive_garbles = 0  # a parsed call ends the garble streak
+            last_garble_idx = None
 
             # Terminal tool -> end the turn cleanly, but enforce verify-before-done
             # (forge's prerequisite idea): if files were changed and nothing has been
@@ -1497,7 +1596,9 @@ class Agent:
                     # nudges ran out) becomes a resumable hard stop, not a success
                     # (matplotlib-25332 r3: done accepted at 84s with edits in tree
                     # and zero successful post-edit commands).
-                    self.budget_note = guardrails.progress_note(self.messages)
+                    self.budget_note = guardrails.progress_note(
+                        self.messages,
+                        rejected_claim=str(terminal.get("summary") or ""))
                     log.info("END step %d: DONE blocked by no-empty-diff gate "
                              "(made_edit=%s, unverified_edit=%s) — progress note banked",
                              step, made_edit, unverified_edit)
@@ -1540,6 +1641,8 @@ class Agent:
                         })
                         if audit:
                             done_audit_fired = True
+                            done_audit_bounces += 1
+                            audit_absent_list = guardrails.audit_absent_paths(audit_task)
                             _runway = ((self._turn_budget_s
                                         - (time.monotonic() - turn_start))
                                        if self._turn_budget_s else float("inf"))
@@ -1548,6 +1651,22 @@ class Agent:
                             self.messages.append({"role": "tool", "name": "done",
                                                   "content": audit})
                             continue
+                    # Absent-path re-bounce (see the final-answer twin above): a
+                    # still-absent task-named path at accept time gets ONE more bounce,
+                    # then the next done is accepted unconditionally.
+                    if done_audit_fired and done_audit_bounces < 2 and audit_absent_list:
+                        _runway = ((self._turn_budget_s
+                                    - (time.monotonic() - turn_start))
+                                   if self._turn_budget_s else None)
+                        rebounce = guardrails.audit_rebounce(audit_absent_list, _runway)
+                        if rebounce:
+                            done_audit_bounces += 1
+                            audit_absent_list = []
+                            log.info("DONE-AUDIT rebounce: still-absent task paths, "
+                                     "runway=%s", _runway)
+                            self.messages.append({"role": "tool", "name": "done",
+                                                  "content": rebounce})
+                            continue
                 # Iter-3 deliverable recheck (levers.done_spec_recheck): one last self-check
                 # that the required outputs actually exist at the right path/format before
                 # we accept done — the hidden container-end-state verifier gives no second
@@ -1820,7 +1939,18 @@ class Agent:
             if made_edit and not _gov_prev_made:
                 readonly_streak = 0
             elif did_work and not made_edit:
-                readonly_streak += 1
+                # A bash step that isn't provably read-only is ACTION, not
+                # investigation — `git merge`, `apt-get install`, redirects are ops
+                # progress. Otherwise the gate can count an entire git/ops workflow as
+                # "investigation" and demand an edit at a decision point where there is
+                # nothing to edit yet.
+                if levers.enabled("gate_ops_exempt") and any(
+                        n == "bash"
+                        and not guardrails.is_readonly_bash(str(a.get("command", "")))
+                        for n, a in calls):
+                    readonly_streak = 0
+                else:
+                    readonly_streak += 1
             if not read_only_intent:
                 gate = guardrails.investigation_gate(readonly_streak, made_edit, gate_nudges)
                 if gate:

{chad_code-1.0.1 → chad_code-1.0.3}/src/chad/cli.py

@@ -637,9 +637,24 @@ def main():
         # ships as an empty diff (the NIGHT-7 bail signature).
         continues = args.auto_continue if args.auto_continue is not None \
             else (2 if run_mode == "auto" else 0)
-        while agent.budget_note and continues > 0:
+        used_continues = 0
+        while agent.budget_note:
+            # Base allowance first; past it, keep granting fresh attempts while most
+            # of the task wall is still unspent (bounded by AUTO_CONTINUE_TOTAL_CAP) —
+            # the fixed base is wall-blind: build-pov-ray (TB2.1 v1.0.0) gave up after
+            # 3 step-capped turns with 94.7% of a 12000s budget unused (plan 107 F3).
+            if continues > 0:
+                continues -= 1
+            elif (args.auto_continue is None and args.turn_budget_s
+                    and guardrails.replenish_continue(
+                        args.turn_budget_s, time.monotonic() - task_start,
+                        used_continues)):
+                sys.stderr.write("[governor] wall budget mostly unspent — granting an "
+                                 "extra continue\n")
+            else:
+                break
+            used_continues += 1
             note = agent.budget_note
-            continues -= 1
             # The wall budget is a TASK-level deadline (the harness SIGKILLs the whole chad
             # process), not a per-turn one: a relaunch must inherit only the wall time that
             # REMAINS, or the governor / wrap-up / hard-abort windows (measured from each