code-context-control 2.136.0__tar.gz → 2.138.0__tar.gz

{code_context_control-2.136.0 → code_context_control-2.138.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.136.0
+Version: 2.138.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.136.0 → code_context_control-2.138.0}/cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.136.0"
+__version__ = "2.138.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):

{code_context_control-2.136.0 → code_context_control-2.138.0}/cli/guide/tools.html

@@ -940,7 +940,7 @@ c3_status(view=<span class="str">'sessions'</span>)         <span class="com">#
                 <td class="param-name">tier</td>
                 <td class="param-type">string</td>
                 <td class="param-default">"small"</td>
-                <td class="param-desc"><code>small</code> · <code>medium</code> · <code>large</code> · <code>default</code>. Claude: Haiku / Sonnet / Opus. Codex and Grok: reasoning effort low / medium / high on the account's model. Gemini: flash-lite / flash / pro.</td>
+                <td class="param-desc"><code>small</code> · <code>medium</code> · <code>large</code> · <code>default</code>. Claude: Haiku (thinking capped at 1024 tokens) / Sonnet / Opus; a scout defaults to Sonnet, which finds things in far fewer turns. Codex and Grok: reasoning effort low / medium / high on the account's model. Gemini: flash-lite / flash / pro.</td>
               </tr>
               <tr>
                 <td class="param-name">model</td>

{code_context_control-2.136.0 → code_context_control-2.138.0}/cli/mcp_server.py

@@ -809,7 +809,7 @@ async def c3_delegate(task: str, task_type: str = "ask", context: str = "",
                 ctx: Context = None) -> str:
     """OFFLOAD to another model — use when the subtask is local-model-sized or needs a different perspective.
     backend: host (default: your own provider, one tier down — Claude Code->claude, Codex->codex, Grok->grok, Antigravity->gemini) | claude|codex|gemini|grok|ollama|auto. task_type: auto, summarize, explain, review, ask, test, diagnose, ping (live auth check), available, codex_check, gemini_check, grok_check, codex_resume.
-    tier: small (default) | medium | large | default. claude: haiku/sonnet/opus; codex/grok: reasoning effort; gemini: flash-lite/flash/pro. model overrides the tier. Context + file_path are packed by C3 under Access Guard; a file over 8k tokens goes as its map, so for line-level questions on a big file paste the excerpt or use scout=true.
+    tier: small (default; scout=true defaults to medium) | medium | large | default. claude: haiku/sonnet/opus; codex/grok: reasoning effort; gemini: flash-lite/flash/pro. model overrides the tier. Context + file_path are packed by C3 under Access Guard; a file over 8k tokens goes as its map, so for line-level questions on a big file paste the excerpt or use scout=true.
     scout=true: the delegate may Read/Grep/Glob the project itself (claude: read-only, guard-denied paths refused; codex: its read-only sandbox) — for lookups when you cannot name the files.
     grok runs read-only in a temp dir unless delegate.grok_allow_write=true (then --yolo in the project, loading its trusted .grok MCP servers and hooks).
     allow_write_delegation: explicit user opt-in for write-capable backends (gemini/grok write mode/codex_resume) while Access Guard rules are active; codex is pinned read-only instead."""

{code_context_control-2.136.0 → code_context_control-2.138.0}/cli/tools/delegate.py

@@ -431,7 +431,56 @@ def scout_settings(project_path) -> dict:
     }
 
 
-def resolve_claude_tier(tier: str, model: str, dcfg: dict) -> tuple[str, str, str]:
+_EFFORT_LEVELS = frozenset({"low", "medium", "high", "xhigh", "max"})
+
+
+def claude_effort_for(tier: str, dcfg: dict) -> str:
+    """``--effort`` for a resolved tier: ``claude_effort`` overrides every
+    tier, else ``claude_tier_effort[tier]``, else none (the CLI's default).
+    An unknown level is ignored rather than passed to argv."""
+    value = str(dcfg.get("claude_effort") or "").strip().lower()
+    if not value:
+        table = dcfg.get("claude_tier_effort") or {}
+        value = str(table.get(tier) or "").strip().lower() if isinstance(table, dict) else ""
+    return value if value in _EFFORT_LEVELS else ""
+
+
+def claude_thinking_cap_for(tier: str, dcfg: dict) -> int | None:
+    """``MAX_THINKING_TOKENS`` for a resolved tier, or None (no cap).
+
+    ``claude_thinking_tokens`` overrides every tier, else
+    ``claude_tier_thinking_tokens[tier]``. 0 turns thinking off. Unlike
+    ``--effort`` (no measurable effect on Haiku 4.5), this is what moves a
+    delegate's cost: one Haiku review went from 4,831 output tokens and 54 s
+    uncapped to 1,186 and 12 s at 1024. A negative or non-integer value is
+    ignored.
+    """
+    value = dcfg.get("claude_thinking_tokens")
+    if value is None or value == "":
+        table = dcfg.get("claude_tier_thinking_tokens") or {}
+        value = table.get(tier) if isinstance(table, dict) else None
+    if value is None or value == "" or isinstance(value, bool):
+        return None
+    try:
+        cap = int(value)
+    except (TypeError, ValueError):
+        return None
+    return cap if cap >= 0 else None
+
+
+def claude_default_tier_key(scout: bool) -> str:
+    """Which config key names the default Claude tier.
+
+    A scout defaults to its own key (medium): measured 2026-09-14, a Haiku
+    scout took 28 turns and $0.24 to find one function that Sonnet found in
+    8 turns for $0.046; the eval's canary case showed the same (15 turns
+    against 2).
+    """
+    return "claude_scout_default_tier" if scout else "claude_default_tier"
+
+
+def resolve_claude_tier(tier: str, model: str, dcfg: dict,
+                        scout: bool = False) -> tuple[str, str, str]:
     """(tier, model_arg, error). An explicit ``model`` wins over the tier.
 
     ``model_arg`` empty means omit --model. ``error`` is non-empty when the
@@ -441,7 +490,7 @@ def resolve_claude_tier(tier: str, model: str, dcfg: dict) -> tuple[str, str, st
         if not _MODEL_NAME_RE.match(model):
             return "", "", f"model name {model!r} is not a Claude model alias or id"
         return "custom", model, ""
-    resolved = normalize_tier(tier, dcfg, "claude_default_tier")
+    resolved = normalize_tier(tier, dcfg, claude_default_tier_key(scout))
     if not resolved:
         return "", "", f"unknown tier {tier!r} (use one of {', '.join(CLAUDE_TIERS)})"
     table = {**CLAUDE_TIER_MODELS, **(dcfg.get("claude_tier_models") or {})}
@@ -483,10 +532,15 @@ def _claude_cmd(exe: str, model: str, system_prompt: str, *, effort: str = "",
     return cmd
 
 
-def _claude_env() -> dict:
+def _claude_env(thinking_cap: int | None = None) -> dict:
     env = _child_host_env("claude-code")
     for name in _CLAUDE_NESTING_VARS:
         env.pop(name, None)
+    # The caller's own MAX_THINKING_TOKENS must not leak into a delegate: the
+    # cap is decided per tier here, or not set at all.
+    env.pop("MAX_THINKING_TOKENS", None)
+    if thinking_cap is not None:
+        env["MAX_THINKING_TOKENS"] = str(int(thinking_cap))
     return env
 
 
@@ -559,7 +613,8 @@ def parse_claude_json(stdout: str, requested_model: str = "") -> tuple[str, bool
 def _run_claude(prompt: str, system_prompt: str, model: str = "", *,
                 timeout: int = 120, effort: str = "",
                 max_budget_usd: float = 0.0, scout_project: str | None = None,
-                settings: dict | None = None) -> tuple[str, bool, dict]:
+                settings: dict | None = None,
+                thinking_cap: int | None = None) -> tuple[str, bool, dict]:
     """Run the locked-down ``claude -p``.
 
     Tool-less (default): in a throwaway directory. Scout (``scout_project``
@@ -580,7 +635,7 @@ def _run_claude(prompt: str, system_prompt: str, model: str = "", *,
             harden_win_argv(cmd),
             stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE,
             text=True, encoding="utf-8", errors="replace", cwd=workdir,
-            env=_claude_env(), **_popen_kwargs(),
+            env=_claude_env(thinking_cap), **_popen_kwargs(),
         )
         stdout, stderr, status = _communicate_with_heartbeat(
             proc, timeout=timeout, idle_timeout=0, stdin_text=prompt)
@@ -671,7 +726,7 @@ def _handle_claude_delegate(task: str, task_type: str, context: str,
         return finalize("c3_delegate", base,
                         "[delegate:error] Claude not enabled. Set delegate.claude_enabled=true "
                         "in .c3/config.json", "disabled")
-    resolved_tier, model_arg, problem = resolve_claude_tier(tier, model, dcfg)
+    resolved_tier, model_arg, problem = resolve_claude_tier(tier, model, dcfg, scout=scout)
     if problem:
         return finalize("c3_delegate", base, f"[delegate:error] {problem}", "error")
     base["tier"] = resolved_tier
@@ -709,14 +764,19 @@ def _handle_claude_delegate(task: str, task_type: str, context: str,
     rules = _CLAUDE_SCOUT_RULES if scout else _CLAUDE_DELEGATE_RULES
     system_prompt = f"{tdef['system']} {rules}"
     prompt = tdef["prompt_template"].format(context=enriched or "(none)", task=task)
-    effort = str(dcfg.get("claude_effort") or "")
+    effort = claude_effort_for(resolved_tier, dcfg)
+    if effort:
+        base["effort"] = effort
+    thinking_cap = claude_thinking_cap_for(resolved_tier, dcfg)
+    if thinking_cap is not None:
+        base["thinking_cap"] = thinking_cap
     try:
         budget = float(dcfg.get("claude_max_budget_usd") or 0.0)
     except (TypeError, ValueError):
         budget = 0.0
 
     ckey = hashlib.md5(
-        f"claude|{resolved_tier}|{model_arg}|{effort}|{system_prompt}|{prompt}".encode()
+        f"claude|{resolved_tier}|{model_arg}|{effort}|{thinking_cap}|{system_prompt}|{prompt}".encode()
     ).hexdigest()
     if not scout and ckey in _delegate_cache:
         cached_resp, _ = _delegate_cache[ckey]
@@ -733,7 +793,7 @@ def _handle_claude_delegate(task: str, task_type: str, context: str,
     output, ok, stats = _run_claude(prompt, system_prompt, model_arg, timeout=timeout,
                                     effort=effort, max_budget_usd=budget,
                                     scout_project=str(svc.project_path) if scout else None,
-                                    settings=settings)
+                                    settings=settings, thinking_cap=thinking_cap)
     elapsed = round(time.monotonic() - t0, 1)
     meta = {**base, "model": stats.pop("model", "") or model_arg or "cli-default",
             "elapsed": f"{elapsed}s", **stats}
@@ -2096,6 +2156,11 @@ def delegate_telemetry_detail(meta: dict | None, status, *, requested_backend: s
     for key in ("tier", "model", "mode", "effort"):
         if meta.get(key):
             detail[key] = str(meta[key])
+    if meta.get("thinking_cap") is not None and not isinstance(meta.get("thinking_cap"), bool):
+        try:
+            detail["thinking_cap"] = int(meta["thinking_cap"])
+        except (TypeError, ValueError):
+            pass
     if raw_status in _CONFIDENCE:
         detail["confidence"] = raw_status
     if meta.get("cached"):
@@ -2167,20 +2232,25 @@ def handle_delegate(task: str, task_type: str, context: str, file_path: str,
                     tier: str = "", model: str = "", scout: bool = False) -> str:
     finalize = _telemetry_finalize(finalize, svc, requested_backend=backend,
                                    task_type=task_type)
+    route = {"backend": backend}
     try:
         return _route_delegate(task, task_type, context, file_path, svc, finalize, backend,
-                               allow_write_delegation, tier, model, scout)
+                               allow_write_delegation, tier, model, scout, route)
     except access_guard.AccessDenied as exc:
         # A guard refusal while packing file_path is the answer, not a crash:
         # the refusal text goes back as the response (the agent reads the
-        # same S1 line c3_read would give) and telemetry counts it as blocked.
-        return finalize("c3_delegate", {"task_type": task_type, "backend": backend},
-                        exc.message, "blocked")
+        # same S1 line c3_read would give) and telemetry counts it as blocked,
+        # under the backend routing had chosen (not 'host' or 'auto').
+        meta = {"task_type": task_type, "backend": route["backend"]}
+        if route.get("tier"):
+            meta["tier"] = route["tier"]
+        return finalize("c3_delegate", meta, exc.message, "blocked")
 
 
 def _route_delegate(task: str, task_type: str, context: str, file_path: str,
                     svc, finalize, backend: str, allow_write_delegation: bool,
-                    tier: str, model: str, scout: bool) -> str:
+                    tier: str, model: str, scout: bool, route: dict | None = None) -> str:
+    route = route if route is not None else {}
     if task_type == "ping":
         finalize = _ping_finalize(finalize)
         task, context, file_path, task_type = PING_TASK, "", "", "ask"
@@ -2264,6 +2334,8 @@ def _route_delegate(task: str, task_type: str, context: str, file_path: str,
         provider, mapped = host_backend(svc)
         if mapped:
             host_tier = normalize_tier("", dcfg, "claude_default_tier" if mapped == "claude" else "")
+            if mapped == "claude":
+                host_tier += f", scout {normalize_tier('', dcfg, claude_default_tier_key(True))}"
             lines.append(f"  host={provider} -> {mapped} (default tier {host_tier}); "
                          "task_type='ping' makes a live call")
         else:
@@ -2337,7 +2409,8 @@ def _route_delegate(task: str, task_type: str, context: str, file_path: str,
         if mapped and not blocked:
             backend = mapped
             if not tier and not model:
-                route_tier = normalize_tier("", dcfg, "claude_default_tier" if mapped == "claude" else "")
+                route_tier = normalize_tier(
+                    "", dcfg, claude_default_tier_key(scout) if mapped == "claude" else "")
         else:
             why = (f"host {provider} -> {mapped} blocked by Access Guard (write-capable)" if blocked
                    else f"host {provider or 'unknown'} has no same-provider backend")
@@ -2394,6 +2467,12 @@ def _route_delegate(task: str, task_type: str, context: str, file_path: str,
             f"or run {backend} directly.",
             "blocked")
 
+    route["backend"] = backend
+    if backend == "claude" and not model:
+        route["tier"] = normalize_tier(route_tier, dcfg, claude_default_tier_key(scout))
+    elif route_tier:
+        route["tier"] = route_tier
+
     # Tier/model reach a handler only when asked for (or set by host routing),
     # so an explicit backend with neither keeps its configured behaviour.
     tier_kw = {k: v for k, v in (("tier", route_tier), ("model", model)) if v}

{code_context_control-2.136.0 → code_context_control-2.138.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.136.0
+Version: 2.138.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.136.0 → code_context_control-2.138.0}/code_context_control.egg-info/SOURCES.txt

@@ -368,6 +368,8 @@ tests/test_delegate_grok.py
 tests/test_delegate_host_d2.py
 tests/test_delegate_scout_d3.py
 tests/test_delegate_telemetry_d0.py
+tests/test_delegate_thinking_cap.py
+tests/test_delegate_tuning.py
 tests/test_delegate_version_probe.py
 tests/test_dir_map_c3.py
 tests/test_e2e_benchmark.py

{code_context_control-2.136.0 → code_context_control-2.138.0}/core/config.py

@@ -297,12 +297,20 @@ DELEGATE_DEFAULTS = {
     # Claude Code CLI (same-provider tier downshift; locked-down, tool-less `claude -p`)
     "claude_enabled": True,               # Master switch — enable Claude as delegate backend
     "claude_default_tier": "",            # Empty = default_tier
+    "claude_scout_default_tier": "medium",  # scout=true without tier/model: Sonnet (Haiku scouts flail: 28 turns vs 8)
     "claude_tier_models": {"small": "haiku", "medium": "sonnet", "large": "opus"},  # CLI aliases, not ids
     "claude_timeout": 120,                # Subprocess timeout in seconds (no idle kill: JSON arrives at the end)
     "claude_scout_timeout": 240,          # scout=true runs look files up first, so they get longer
     "claude_max_context_tokens": 24000,   # Context cap after file packing
     "claude_file_max_tokens": 8000,       # A file_path entry over this is sent as its file map
-    "claude_effort": "",                  # --effort low|medium|high|xhigh|max; empty = CLI default
+    "claude_effort": "",                  # --effort for every tier (overrides claude_tier_effort); empty = per tier
+    "claude_thinking_tokens": None,       # MAX_THINKING_TOKENS for every tier (overrides the table); 0 = off
+    "claude_tier_thinking_tokens": {"small": 1024},  # MAX_THINKING_TOKENS per tier; unlisted = no cap.
+                                          # Haiku at 1024: real-file reviews ~55% cheaper, 2.6x faster, no
+                                          # accuracy loss seen. Sonnet 5 ignored nonzero caps, and 0 cost it depth.
+    "claude_tier_effort": {},             # --effort per tier, e.g. {"medium": "low"}; unlisted = CLI default
+                                          # (2026-09-14: --effort low changed nothing on Haiku 4.5 — same
+                                          # cost and output tokens over 22 eval cases — so no default)
     "claude_max_budget_usd": 0,           # --max-budget-usd per call; 0 = no cap
 }
 

{code_context_control-2.136.0 → code_context_control-2.138.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.136.0"
+version = "2.138.0"
 description = "Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.136.0 → code_context_control-2.138.0}/services/bench/delegate_eval.py

@@ -154,7 +154,8 @@ def resolve_suite(name_or_path: str) -> Path:
 
 
 def parse_target(spec: str) -> tuple[str, str]:
-    """``backend``, ``backend:tier`` or either with ``+scout`` -> (backend, tier)."""
+    """``backend`` or ``backend:tier``, optionally with ``+scout`` / ``+think=N``
+    / ``+effort=X`` flags -> (backend, tier)."""
     head = str(spec).strip().split("+", 1)[0]
     backend, _, tier = head.partition(":")
     if not backend:
@@ -165,10 +166,18 @@ def parse_target(spec: str) -> tuple[str, str]:
 # ── Checks ──────────────────────────────────────────────────────────────────
 
 
+_EMPHASIS_RE = re.compile(r"\*\*|__")
+
+
 def grade(case: DelegateCase, answer: str) -> list[str]:
-    """Failed checks for ``answer`` (empty list = pass)."""
+    """Failed checks for ``answer`` (empty list = pass).
+
+    Bold markers are removed before matching: "does **not** match" is the
+    same answer as "does not match" (a correct Haiku answer failed on
+    exactly that). Backticks stay — some checks are about code spans.
+    """
     failures: list[str] = []
-    text = answer or ""
+    text = _EMPHASIS_RE.sub("", answer or "")
     flags = re.IGNORECASE | re.MULTILINE
     for pattern in case.checks.get("must_match", []):
         if not re.search(pattern, text, flags):
@@ -280,12 +289,34 @@ def build_eval_svc(project_path: str | Path, delegate_overrides: dict | None = N
     )
 
 
+_TARGET_OVERRIDES = {"think": "claude_thinking_tokens", "effort": "claude_effort"}
+
+
+def target_overrides(target: str) -> dict:
+    """Delegate-config overrides named in a target: ``+think=N`` sets
+    ``claude_thinking_tokens``, ``+effort=low`` sets ``claude_effort``. So one
+    run can compare ``claude:small``, ``claude:small+think=1024`` and
+    ``claude:small+think=0`` side by side."""
+    out: dict = {}
+    for flag in str(target).split("+")[1:]:
+        key, sep, value = flag.partition("=")
+        key = key.strip().lower()
+        if not sep or key not in _TARGET_OVERRIDES:
+            continue
+        value = value.strip()
+        out[_TARGET_OVERRIDES[key]] = int(value) if key == "think" and value.isdigit() else value
+    return out
+
+
 def run_live_case(case: DelegateCase, target: str, svc, *,
                   allow_write_delegation: bool = False) -> tuple[CaseResult, dict]:
     """Send one case through handle_delegate. Returns (result, recording)."""
     from cli.tools.delegate import handle_delegate
 
     backend, tier = parse_target(target)
+    overrides = target_overrides(target)
+    if overrides:
+        svc = types.SimpleNamespace(**{**vars(svc), "delegate_config": {**svc.delegate_config, **overrides}})
     captured: dict = {}
 
     def finalize(tool, meta, output, status, **kw):

{code_context_control-2.136.0 → code_context_control-2.138.0}/tests/test_delegate_eval.py

@@ -78,6 +78,13 @@ def test_every_reference_answer_passes_and_every_wrong_answer_fails():
     assert report.aggregates["wrong"]["pass_rate_core"] == 0.0
 
 
+def test_grade_ignores_bold_but_not_code_spans():
+    case = _case(checks={"any_match": ["does not"], "must_not_match": ["`FOO"]})
+    assert de.grade(case, "This does **not** match the docstring.") == []
+    assert de.grade(case, "It does __not__ match.") == []
+    assert de.grade(case, "does not; see `FOO=1`") != []
+
+
 def test_grade_checks():
     case = _case(checks={"must_match": [r"\b7\b"], "any_match": ["retr", "attempt"],
                          "must_not_match": ["maybe"], "max_words": 5})

{code_context_control-2.136.0 → code_context_control-2.138.0}/tests/test_delegate_host_d2.py

@@ -309,8 +309,10 @@ def test_available_names_the_host(monkeypatch):
     for name in ("codex", "gemini", "claude", "grok"):
         monkeypatch.setattr(delegate, f"check_{name}", lambda n=name: {"status": "ok", "version": n})
     store = {}
-    delegate.handle_delegate("", "available", "", "", _svc(ollama=_FakeOllama(["llama3.2:3b"])), _capture(store))
-    assert "  host=claude-code -> claude (default tier small)" in store["resp"]
+    delegate.handle_delegate("", "available", "", "",
+                             _svc(ollama=_FakeOllama(["llama3.2:3b"]), claude_scout_default_tier="medium"),
+                             _capture(store))
+    assert "  host=claude-code -> claude (default tier small, scout medium)" in store["resp"]
     assert "(--version only)" in store["resp"]
 
 

code_context_control-2.138.0/tests/test_delegate_thinking_cap.py

@@ -0,0 +1,134 @@
+"""Per-tier thinking cap (MAX_THINKING_TOKENS) for the claude delegate.
+
+--effort low had no measurable effect on Haiku 4.5 (2.137.0). A thinking cap
+did: one Haiku review went from 4,831 output tokens / 54 s uncapped to 1,186 /
+12 s at 1024 and 308 / 6 s at 0. These tests pin the plumbing; the defaults
+come from the eval recorded in the CHANGELOG.
+"""
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from cli.tools import delegate
+from core.config import DELEGATE_DEFAULTS
+from services.bench import delegate_eval as de
+
+
+def _svc(tmp, **cfg):
+    return SimpleNamespace(project_path=str(tmp), delegate_config={**DELEGATE_DEFAULTS, **cfg},
+                           notifications=None, compressor=None, ollama_client=None, session_mgr=None,
+                           _agent_progress_cb=None)
+
+
+@pytest.fixture(autouse=True)
+def _clean(monkeypatch):
+    delegate._backend_breakers.clear()
+    delegate._delegate_cache.clear()
+    monkeypatch.setattr(delegate.access_guard, "has_active_rules", lambda _p: False)
+    yield
+    delegate._delegate_cache.clear()
+
+
+@pytest.fixture
+def runs(monkeypatch):
+    calls = []
+
+    def fake_run(prompt, system_prompt, model="", **kw):
+        calls.append({"model": model, **kw})
+        return "answer", True, {"model": model}
+
+    monkeypatch.setattr(delegate, "_run_claude", fake_run)
+    return calls
+
+
+def test_defaults_cap_haiku_only(runs, tmp_path):
+    assert DELEGATE_DEFAULTS["claude_thinking_tokens"] is None
+    assert DELEGATE_DEFAULTS["claude_tier_thinking_tokens"] == {"small": 1024}
+    finalize = lambda tool, meta, resp, status, **kw: resp  # noqa: E731
+    delegate.handle_delegate("a", "ask", "ctx", "", _svc(tmp_path), finalize, backend="claude")
+    delegate.handle_delegate("b", "ask", "ctx", "", _svc(tmp_path), finalize, backend="claude", tier="medium")
+    delegate.handle_delegate("c", "ask", "", "", _svc(tmp_path), finalize, backend="claude", scout=True)
+    assert [(r["model"], r["thinking_cap"]) for r in runs] == [("haiku", 1024), ("sonnet", None), ("sonnet", None)]
+
+
+@pytest.mark.parametrize("cfg, tier, expected", [
+    ({}, "small", None),
+    ({"claude_tier_thinking_tokens": {"small": 1024}}, "small", 1024),
+    ({"claude_tier_thinking_tokens": {"small": 1024}}, "medium", None),
+    ({"claude_tier_thinking_tokens": {"small": 0}}, "small", 0),            # 0 = thinking off, not "unset"
+    ({"claude_thinking_tokens": 4096, "claude_tier_thinking_tokens": {"small": 0}}, "small", 4096),
+    ({"claude_thinking_tokens": 0}, "large", 0),
+    ({"claude_tier_thinking_tokens": {"small": "2048"}}, "small", 2048),
+    ({"claude_tier_thinking_tokens": {"small": -5}}, "small", None),
+    ({"claude_tier_thinking_tokens": {"small": "lots"}}, "small", None),
+    ({"claude_tier_thinking_tokens": {"small": True}}, "small", None),
+    ({"claude_tier_thinking_tokens": [1024]}, "small", None),
+])
+def test_cap_resolution(cfg, tier, expected):
+    assert delegate.claude_thinking_cap_for(tier, cfg) == expected
+
+
+def test_env_sets_the_cap_and_never_inherits_one(monkeypatch):
+    monkeypatch.setenv("MAX_THINKING_TOKENS", "99999")
+    assert "MAX_THINKING_TOKENS" not in delegate._claude_env()
+    assert delegate._claude_env(0)["MAX_THINKING_TOKENS"] == "0"
+    assert delegate._claude_env(1024)["MAX_THINKING_TOKENS"] == "1024"
+
+
+def test_handler_passes_the_cap_and_records_it(runs, tmp_path):
+    store = {}
+
+    def finalize(tool, meta, resp, status, **kw):
+        store.update(meta=meta)
+        return resp
+
+    cfg = {"claude_tier_thinking_tokens": {"small": 512}}
+    delegate.handle_delegate("q", "ask", "ctx", "", _svc(tmp_path, **cfg), finalize, backend="claude")
+    assert runs[-1]["thinking_cap"] == 512 and store["meta"]["thinking_cap"] == 512
+    delegate.handle_delegate("q2", "ask", "ctx", "", _svc(tmp_path, **cfg), finalize, backend="claude",
+                             tier="large")
+    assert runs[-1]["thinking_cap"] is None and "thinking_cap" not in store["meta"]
+
+
+def test_cap_changes_the_cache_key(runs, tmp_path):
+    finalize = lambda tool, meta, resp, status, **kw: resp  # noqa: E731
+    delegate.handle_delegate("same", "ask", "ctx", "", _svc(tmp_path, claude_thinking_tokens=0), finalize,
+                             backend="claude")
+    delegate.handle_delegate("same", "ask", "ctx", "", _svc(tmp_path, claude_thinking_tokens=1024), finalize,
+                             backend="claude")
+    assert len(runs) == 2
+
+
+def test_telemetry_detail_keeps_a_zero_cap():
+    d = delegate.delegate_telemetry_detail({"backend": "claude", "tier": "small", "thinking_cap": 0}, "ok",
+                                           requested_backend="host", task_type="ask", host="", wall_ms=1)
+    assert d["thinking_cap"] == 0
+
+
+def test_eval_target_flags():
+    assert de.target_overrides("claude:small") == {}
+    assert de.target_overrides("claude:small+think=1024") == {"claude_thinking_tokens": 1024}
+    assert de.target_overrides("claude:medium+scout+think=0+effort=low") == {
+        "claude_thinking_tokens": 0, "claude_effort": "low"}
+    assert de.target_overrides("claude:small+colour=red") == {}
+    assert de.parse_target("claude:small+think=0") == ("claude", "small")
+
+
+def test_eval_live_case_applies_target_overrides_to_a_copy(monkeypatch):
+    seen = []
+
+    def fake_handle(task, task_type, context, file_path, svc, finalize, backend, **kw):
+        seen.append(dict(svc.delegate_config))
+        return finalize("c3_delegate", {"backend": backend}, "x", "ok")
+
+    monkeypatch.setattr("cli.tools.delegate.handle_delegate", fake_handle)
+    svc = SimpleNamespace(project_path=".", delegate_config={"claude_thinking_tokens": None})
+    case = de.DelegateCase.from_dict({"id": "c", "task_type": "ask", "task": "t",
+                                      "checks": {"must_match": ["x"]}})
+    de.run_live_case(case, "claude:small+think=0", svc)
+    de.run_live_case(case, "claude:small", svc)
+    assert seen[0]["claude_thinking_tokens"] == 0
+    assert seen[1]["claude_thinking_tokens"] is None
+    assert svc.delegate_config == {"claude_thinking_tokens": None}  # the shared svc is untouched