chad-code 1.0.9__tar.gz → 1.12.0__tar.gz

{chad_code-1.0.9 → chad_code-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chad-code
-Version: 1.0.9
+Version: 1.12.0
 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

{chad_code-1.0.9 → chad_code-1.12.0}/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.9"
+version = "1.12.0"
 description = "Local MLX-backed, Claude-Code-style coding agent (Apple Silicon, Ornith 35B/9B)"
 readme = "README.md"
 license = "MIT"

{chad_code-1.0.9 → chad_code-1.12.0}/src/chad/__init__.py

@@ -4,7 +4,7 @@ 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.9"
+__version__ = "1.12.0"
 
 # chad sets no MLX_* runtime vars. MLX_METAL_FAST_SYNCH, MLX_MAX_OPS_PER_BUFFER
 # and MLX_MAX_MB_PER_BUFFER were each measured end-to-end on the 35B and every

{chad_code-1.0.9 → chad_code-1.12.0}/src/chad/agent.py

@@ -14,7 +14,18 @@ import re
 import sys
 import time
 
-from . import atif, compaction, config, guardrails, levers, session, syntaxgate
+from . import (
+    ambient,
+    atif,
+    checkpoint,
+    compaction,
+    config,
+    guardrails,
+    levers,
+    seatbelt,
+    session,
+    syntaxgate,
+)
 from .base_engine import BackendError, BaseEngine
 from .diag import args_preview, log, redact, result_preview
 from .prompt import build_subagent_prompt, build_system_prompt, classify_intent
@@ -47,7 +58,7 @@ SUBAGENT_MAX_STEPS = 24
 SUBAGENT_CTX_LIMIT = 32000
 SUBAGENT_READ_ONLY = {
     "read", "grep", "glob", "repo_map", "overview", "view_symbol",
-    "find_symbol", "find_refs", "done", "finish", "stop",
+    "find_symbol", "definition", "find_refs", "done", "finish", "stop",
 }
 # `write_todos` is deliberately absent: a sub-agent that plans its own work would mutate
 # the process-global `_TODOS` and clobber the parent's pinned todo panel (and `_sub_emit`
@@ -346,6 +357,8 @@ class Agent:
             skills.reset_session()
             from . import mcp
             mcp.reset_session()
+            ambient.reset()  # fresh session-state ledger; sub-agents share the
+                             # parent's and never feed it (see run_turn)
         self.mode = mode or ("yolo" if yolo else "normal")
         self.thinking = thinking  # Ornith is a reasoning model; toggles <think> blocks
         # Steps per WINDOW, not a hard kill: a window that landed+verified a change
@@ -625,6 +638,7 @@ class Agent:
                 # measured trace: a model re-phrasing the same delete 30 times). The
                 # guard names itself and the fix — narrow the target.
                 if levers.enabled("scoped_destructive_guard"):
+                    levers.fired("scoped_destructive_guard", deny_text=True)
                     self._deny_reason = (
                         "[blocked by the destructive-command guard, not by a person: "
                         "the command matches a catastrophic pattern (recursive delete "
@@ -722,6 +736,7 @@ class Agent:
                 note = sub.budget_note or guardrails.progress_note(sub.messages)
                 if not note:
                     return res
+                levers.fired("subagent_budget_note")
                 return (res.rstrip() + "\n[sub-agent progress before it "
                         f"stopped: {note}]").strip()
             if sub.interrupted:
@@ -1196,6 +1211,7 @@ class Agent:
                         or self._backend_retries >= _MAX_BACKEND_RETRIES):
                     raise
                 self._backend_retries += 1
+                levers.fired("backend_retry", attempt=self._backend_retries)
                 log.warning("backend error (retry %d/%d): %s",
                             self._backend_retries, _MAX_BACKEND_RETRIES, e)
                 self._emit("status", f"Backend error; retrying "
@@ -1285,6 +1301,8 @@ class Agent:
                 # the first branch already credits; an unclosed generation that
                 # stopped SHORT of the cap is a truncation of some other kind, not
                 # the reasoning overspend this counts.
+                levers.fired("capped_think_credit", step=step,
+                             tokens=stats.generated_tokens)
                 _think_delta = stats.generated_tokens
             else:
                 _think_delta = 0
@@ -1312,6 +1330,7 @@ class Agent:
                 if _tt_decision == "half":
                     log.info("THINK-BUDGET half at step %d: %d/%d cumulative think tok "
                              "this turn", step, turn_think_tokens, _tt_budget)
+                    levers.fired("turn_think_budget", step=step, decision="half")
                     self.messages.append({"role": "tool", "name": "steer",
                                           "content": guardrails.TURN_THINK_BUDGET_STEER})
                 elif _tt_decision == "exhausted":
@@ -1319,6 +1338,7 @@ class Agent:
                              "tok this turn — throttling <think> (one action step per "
                              "%d further think tok)", step, turn_think_tokens,
                              _tt_budget, guardrails.TURN_THINK_REARM_TOK)
+                    levers.fired("turn_think_budget", step=step, decision="exhausted")
                     self._emit("info", "  [reasoning budget exhausted for this turn — "
                                        "throttling further <think>]")
 
@@ -1388,6 +1408,8 @@ class Agent:
                 hard_wrapup_fired = True
                 landing_no_think = True
                 _remaining = self._turn_budget_s - (time.monotonic() - turn_start)
+                levers.fired("hard_wrapup", step=step,
+                             remaining_s=int(_remaining))
                 log.info("HARD-WRAPUP abort at step %d: %.0fs left, gen was %d tok",
                          step, _remaining, stats.generated_tokens)
                 self._emit("info", "  [wall deadline reached — landing the best answer now]")
@@ -1452,6 +1474,7 @@ class Agent:
                     capped_stall_streak += 1
                     if (self.think_ceiling and self.thinking and capped_stall_streak >= 2
                             and levers.enabled("no_think_escalation")):
+                        levers.fired("no_think_escalation", step=step)
                         no_think_next = True
                 else:
                     capped_stall_streak = 0
@@ -1481,6 +1504,7 @@ class Agent:
                     # 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):
+                        levers.fired("garble_never_final", step=step, action="scrub")
                         self.messages[last_garble_idx]["content"] = \
                             guardrails.GARBLE_SCRUBBED
                         log.info("GARBLE scrub at step %d: previous garbled message "
@@ -1516,6 +1540,7 @@ class Agent:
                 # 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"):
+                    levers.fired("garble_never_final", step=step, action="hard-stop")
                     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",
@@ -1558,6 +1583,8 @@ class Agent:
                         if audit:
                             done_audit_fired = True
                             done_audit_bounces += 1
+                            levers.fired("done_audit", step=step, entry="churn-handoff")
+                            levers.fired("audit_churn_handoff", step=step)
                             audit_absent_list = guardrails.audit_absent_paths(audit_task)
                             _runway = ((self._turn_budget_s
                                         - (time.monotonic() - turn_start))
@@ -1607,6 +1634,7 @@ class Agent:
                     if audit:
                         done_audit_fired = True
                         done_audit_bounces += 1
+                        levers.fired("done_audit", step=step, entry="final-answer")
                         audit_absent_list = guardrails.audit_absent_paths(audit_task)
                         _runway = ((self._turn_budget_s
                                     - (time.monotonic() - turn_start))
@@ -1681,10 +1709,15 @@ class Agent:
                     log.info("DONE rejected: edits not verified -> nudge #%d", verify_nudges)
                     self.messages.append({
                         "role": "tool", "name": "done",
+                        # The session-ledger facts (what changed, what last ran) ride
+                        # the bounce when the lever is on — the model's stale state
+                        # model IS the wrong-verify bug.
                         "content": "[not done yet: you changed files but have not run anything "
                                    "to verify them. Run the project's tests (or the code) with "
                                    "bash, check the output is correct, then call done. If a test "
-                                   "fails, fix the code first.]",
+                                   "fails, fix the code first.]"
+                                   + ("" if self._subagent else
+                                      ambient.ledger_suffix(step=step, force=True)),
                     })
                     continue
                 if action_task and not read_only_intent and self.mode != "plan" \
@@ -1706,6 +1739,9 @@ class Agent:
                         if audit:
                             done_audit_fired = True
                             done_audit_bounces += 1
+                            levers.fired("done_audit", step=step,
+                                         entry="churn-handoff-done")
+                            levers.fired("audit_churn_handoff", step=step)
                             audit_absent_list = guardrails.audit_absent_paths(audit_task)
                             _runway = ((self._turn_budget_s
                                         - (time.monotonic() - turn_start))
@@ -1768,14 +1804,18 @@ class Agent:
                         if audit:
                             done_audit_fired = True
                             done_audit_bounces += 1
+                            levers.fired("done_audit", step=step, entry="done")
                             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"))
                             log.info("DONE-AUDIT bounce: paths=%s runway=%.0fs",
                                      guardrails.audit_extract_paths(audit_task), _runway)
-                            self.messages.append({"role": "tool", "name": "done",
-                                                  "content": audit})
+                            self.messages.append({
+                                "role": "tool", "name": "done",
+                                # Session-ledger facts ride the audit bounce
+                                "content": audit
+                                + ambient.ledger_suffix(step=step, force=True)})
                             continue
                     # Absent-path re-bounce (see the final-answer twin above): a
                     # still-absent task-named path at accept time gets ONE more bounce,
@@ -1802,6 +1842,7 @@ class Agent:
                         and guardrails.done_spec_recheck(
                             did_work, unverified_edit, done_recheck_done, read_only_intent):
                     done_recheck_done = True
+                    levers.fired("done_spec_recheck", step=step)
                     log.info("DONE deferred for deliverable recheck (step %d)", step)
                     self.messages.append({"role": "tool", "name": "done",
                                           "content": guardrails.DONE_SPEC_RECHECK})
@@ -1897,6 +1938,7 @@ class Agent:
                     _sub_sig = (str(args.get("description", "")).strip(),
                                 str(args.get("prompt", "")).strip())
                     if _sub_sig in subagent_sigs and levers.enabled("subagent_no_respawn"):
+                        levers.fired("subagent_no_respawn", step=step)
                         result = ("[you already ran this exact sub-agent this turn — do NOT "
                                   "re-run it. Use what it returned, or do the work yourself "
                                   "now with grep/read to locate the code and edit to change "
@@ -1940,12 +1982,27 @@ class Agent:
                 else:
                     _t0 = time.perf_counter()
                     self.tool_dispatches += 1
+                    # A snapshot happens AFTER approval, immediately before the tool
+                    # runs — a denied edit must not leave a checkpoint claiming it ran.
+                    if (name in AUTO_EDIT_TOOLS
+                            and levers.enabled("edit_checkpoint")):
+                        _ref = checkpoint.snapshot(
+                            os.getcwd(), f"before {name} {args.get('path', '')}".strip())
+                        if _ref:
+                            levers.fired("edit_checkpoint", step=step, ref=_ref)
+                    # Seatbelt context is scoped to exactly this dispatch: `active`
+                    # reflects the mode of the agent actually executing, so a
+                    # sub-agent's yolo loop is confined inside a normal-mode parent
+                    # turn, and the context can't leak to the `!cmd` passthrough.
+                    seatbelt.set_context(self.mode == "yolo", os.getcwd())
                     try:
                         result = fn(args, self._should_stop)
                         if plan_write and result.startswith("[wrote"):
                             self.last_plan_path = os.path.abspath(args["path"])
                     except Exception as e:  # noqa: BLE001 - surface tool errors to model
                         result = f"[tool error: {type(e).__name__}: {e}]"
+                    finally:
+                        seatbelt.set_context(False, None)
                     _tool_s = time.perf_counter() - _t0
                     # Backstop: bound the prefill from any tool, AND from the step as a
                     # whole — several calls in one step stack into one prefill, so later
@@ -1960,6 +2017,16 @@ class Agent:
                         log.info("TOOL %s duplicate result elided (%d chars)",
                                  name, len(result))
                         result = _elided
+                    # Ambient state: fold this result into the session
+                    # ledger and append whatever fact lines the enabled levers owe it
+                    # (session_ledger on landed mutations, bash_read_skeleton on file
+                    # content surfacing through bash/read). After the clip cap on
+                    # purpose — a clipped result must still carry its facts; the
+                    # appended text is bounded in ambient.py. Main agent only: a
+                    # sub-agent's transcript folds away and must not pollute the
+                    # parent's ledger.
+                    if not self._subagent:
+                        result = ambient.annotate(name, args, result, step=step)
                     step_tool_chars += len(result)
                     if _PREFILL_TRACE:
                         self._trace_tools_pending.append([name, round(_tool_s, 4)])
@@ -1977,6 +2044,7 @@ class Agent:
                 if (plan_write and result.startswith("[wrote") and not plan_reviews
                         and levers.enabled("plan_review")):
                     plan_reviews += 1
+                    levers.fired("plan_review", step=step)
                     log.info("PLAN REVIEW nudge for %s", self.last_plan_path)
                     self.messages.append({"role": "tool", "name": "read", "content": (
                         f"[plan written to {self.last_plan_path}. Before you call `done`, "
@@ -2087,6 +2155,9 @@ class Agent:
                         n == "bash"
                         and not guardrails.is_readonly_bash(str(a.get("command", "")))
                         for n, a in calls):
+                    if readonly_streak:  # the exemption actually reset a live streak
+                        levers.fired("gate_ops_exempt", step=step,
+                                     streak=readonly_streak)
                     readonly_streak = 0
                 else:
                     readonly_streak += 1