code-context-control 2.136.0__py3-none-any.whl → 2.138.0__py3-none-any.whl

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):

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>

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."""

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.dist-info → code_context_control-2.138.0.dist-info}/METADATA

@@ -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.dist-info → code_context_control-2.138.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 cli/__init__.py,sha256=ec66drCZGNMRU4V6ov0zVhYZph1us12Vn8OvG_LJyRY,22
 cli/_hook_utils.py,sha256=RhfS2WS5VMSi2w2Jxcts1wg5WC-UFp89JOQvcO5Jjb8,23002
 cli/_shell_writes.py,sha256=XzUNlUDljmg-wZxK03xHnRe36WeQxe4tpO9HKVFwP5o,5090
-cli/c3.py,sha256=yJBQIdLwczYGAhFvCShYUK6iihQW5Mnfrzp5ASWF2XE,424321
+cli/c3.py,sha256=nIkboPZD_O0bgTT1Z1wTjBlYy0pNKeL7jXkYUum-Lr0,424321
 cli/docs.html,sha256=pPxcP5ieY0DcfEDvegwIcRxbz1woLZoKLVSF-4JVy0Q,146784
 cli/edits.html,sha256=UjAhoCmBmQ89cklGvJqzC6eyNP2tc8H6T-e01DVkLvE,43418
 cli/hook_access_guard.py,sha256=nzPvuN1zsTiBmOopoYziXRatCeg_qhlKaQLW5lNyUqg,24729
@@ -25,7 +25,7 @@ cli/hook_terse_advisor.py,sha256=W_zaTfX2akgX-ifuUTsLu2H1atM8XmWt6jpPoeU7Pm0,625
 cli/hub_server.py,sha256=Hr-vqN72FuSUVe4lDBSYHygNJZeQscX7iS5ZGxk-sko,196104
 cli/hub_ui.html,sha256=nnGqWhWGCLfNisGUnoAlQFcBr6wPNsq-AEOR7uFtVkE,2942
 cli/mcp_proxy.py,sha256=r-Qhlie7gCtotex8yQUudCyBLRUK-IW6cNIW5RhBW0o,17648
-cli/mcp_server.py,sha256=oWpmT3lUZ68VfvAd1_ohkNcZA2N6IESPdis_VtniKC0,71458
+cli/mcp_server.py,sha256=5mMZqG0cmhbmROWTw-EAzyVMT5sg_lqsHr169ShQvMA,71489
 cli/progress.py,sha256=qTkNy0howOD3hXraMo4ok3dYTpBW5yG_tenKfF4UDM0,1470
 cli/server.py,sha256=vU50-A9PhEFhtcTH8U4VcNlIIglKFyBGk4qbBI_bgWo,173854
 cli/ui.html,sha256=xcdt74nlFEXx-0Bx6-Okw-WSVZPAXL0iukxU0ytI6CA,5694
@@ -42,7 +42,7 @@ cli/guide/index.html,sha256=nNM_gAi3e8SGEUV7jIsd8N3kmAP35BepwmjZ2HuJoSA,22869
 cli/guide/masking.html,sha256=Jz8fEwp5XwudUafn0Ymytofpf4PPWRpyxOHMl09dD5o,19203
 cli/guide/oracle.html,sha256=66utgqoOpHXxZBEopnw-Q-tvhoQOD82YckXW2xDTTJ4,25152
 cli/guide/shared.css,sha256=Mmm7W6aYxrkDq2RPOcyXiQFYGR-yB3auwX1uIWi6C74,15967
-cli/guide/tools.html,sha256=g-NqsEOvEU3vrDlqCQfAQzxdExLul82fD6RpNmQI7iw,95067
+cli/guide/tools.html,sha256=38ES1AeC0AuFnxr-sLZNdTaAVyykpY_-W-AxNH2XVhY,95167
 cli/guide/workflow.html,sha256=aN0eB1wMofm_ii02ydDCiR3FTbsEIuSCMCESCO-TEBA,64601
 cli/hub_ui/app.js,sha256=Gbk-2DxqUynrVqJbS8pNUEHmcCpjuUhqeDxWUWa6e_A,6984
 cli/hub_ui/state.js,sha256=QIRs_ooO8ODgdU0mwiwvIAz7IbiTs17fqLyolXbCeCI,7373
@@ -82,7 +82,7 @@ cli/tools/bitbucket.py,sha256=cni8Y1EoiNm9jcHEpzi2dgKFIT1-4ct0WOhpTs7ac3k,35812
 cli/tools/ci.py,sha256=1--Ak18ikHkO7q4HWlDCVac-U969eEFejkd-24T0xuY,20057
 cli/tools/compress.py,sha256=PcgxEw7KfofmJsTLfRf3mjWMxyNlqkcSNzMTlT27SW0,12534
 cli/tools/credentials.py,sha256=R8Errpa41vsq0Z_sb7K-fmJxVovzXDYUyniITLrFC24,19033
-cli/tools/delegate.py,sha256=XUAfcYxner_Xe9RVwy6GZhvC8Xriq6TNl0ZoPmZlRZQ,109167
+cli/tools/delegate.py,sha256=5a2ZwwNr1w0GfHZaUBMRBtEx2_EWqXKXhsb4GDYOp3Y,112693
 cli/tools/edit.py,sha256=xnRRM2UUybvGvfSzXzIjWmt6_zNaCbkupiK1z-8K4jE,30127
 cli/tools/edit_verify.py,sha256=L1a6U9Z-pAOQz0Ur9SFTNfmCl0OP9_4VdkyxlXOyHDM,11910
 cli/tools/edits.py,sha256=zgVk5FrUmaXK1iJ9sUvz5OfwD0PLeordqnfe6Po7RDs,6271
@@ -125,10 +125,10 @@ cli/ui/components/sessions.js,sha256=FIKtil76B8tCkAmcFV7hlj6GQ_DCJK2jCzvEmdK7NBE
 cli/ui/components/settings.js,sha256=FXcn-UQE2mXC6HFsLeEas-wAUFKt0OJaLySroZQMhGA,84095
 cli/ui/components/sidebar.js,sha256=K2ym2kUgpbyG-EBA_wBIIiqQY8qTatsiBZwzseMWuIQ,9939
 cli/ui/components/tasks.js,sha256=vyKQ3uwoppMwvdEaHlhWXW4oWcAisx4NveqzMhsYqHo,38438
-code_context_control-2.136.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
+code_context_control-2.138.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
 core/__init__.py,sha256=TSDCEcM4V7gcZVM3w2ykJaqEUch4Dkon-rivV17T73s,2501
 core/codex_patch.py,sha256=CxvT_rQIwPNTRJZj9EHJmx0ZdOeSLxjiixuLI3Z7lPc,2107
-core/config.py,sha256=hxxljfQxlMgPj9EFL3mgU_lcbb5MsAAyxz2Xh7KJDnU,21718
+core/config.py,sha256=KRCu5uo_7j-QhMJXXfFwc3f34gVitHv87ngrOqoAcR0,22615
 core/grok_payload.py,sha256=EEwhvkKnCT6Rk9tc-DWDA__toE44244Xr4d6p7SoJwE,5365
 core/hook_command.py,sha256=SvTDUaBLg1Qb4ZdAgpe14YA_8BSnkGJsd3ByPtqBsU0,1032
 core/host.py,sha256=yBzjJjSs2ATyCpGD_IHOJ8n2Pn6RFPhnKHq819CFzC4,1585
@@ -295,7 +295,7 @@ services/vector_store.py,sha256=satc4MJanC1Wsu_iveMCUXG6K2fd0Ke87JSyy2BMikw,1304
 services/watcher.py,sha256=WF6aTIUFzg5B5KepuLyUwmx8WvbmhT9IeenzdK0df3U,10779
 services/win_subprocess.py,sha256=nt8Uwc2PrqsRW3-jcViEsoKj56GudW8TV3CQwryx8y4,4271
 services/bench/__init__.py,sha256=WLEJIWJeaUj6FnH2nDO1qWugJDKfOKeM6WvKLSreYjI,231
-services/bench/delegate_eval.py,sha256=EURLbpXr0HItFWz6gKLB1N6TaogEIscv2hGearAnaTI,24820
+services/bench/delegate_eval.py,sha256=gi_cG8yYlYqBr_yOfyTibdeUJujYYFVyjcVqeIMXlUo,26072
 services/bench/map_eval.py,sha256=i0M3hBJQM9wXX4dMB_2LjVKoFtXzFUKapoqjGB_8tcE,43456
 services/bench/search_eval.py,sha256=HjVDoIs_uTvNhbT_YjhNjCPEweUG5goaUDaipOcjuF4,29234
 services/bench/shell_eval.py,sha256=YW4qFO6JwmHuv-7_aaQG4QcDpXqnSEZ5uqFDigzTo_8,26723
@@ -320,8 +320,8 @@ tui/screens/search_view.py,sha256=MMHjVdlk3HZSuDBSvq8IGrqv_Mh5Us6YqXQ80bcWSMk,19
 tui/screens/session_view.py,sha256=eZ1eDwHTvPOck1wCCviixtOaCxIkBT_95ytNNNriGNA,5991
 tui/screens/stats.py,sha256=p81PjzdaIv7hllb8f45-rlVe4lJZwSdIMqu7e86_u5s,6223
 tui/screens/ui_view.py,sha256=1QJCgLh2YfgWIpvzRG1KOGXYEaOYX6ojN61Azjf2oX0,2125
-code_context_control-2.136.0.dist-info/METADATA,sha256=CaWuvJ7YKzDEAav6ZNh8urmb05XcsOZGor2lbV34Vew,28433
-code_context_control-2.136.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-code_context_control-2.136.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
-code_context_control-2.136.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
-code_context_control-2.136.0.dist-info/RECORD,,
+code_context_control-2.138.0.dist-info/METADATA,sha256=338fmGaLU48EzbmUGfRBzGFJdUxfE3uDtCLpsfOIXcE,28433
+code_context_control-2.138.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+code_context_control-2.138.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
+code_context_control-2.138.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
+code_context_control-2.138.0.dist-info/RECORD,,

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
 }
 

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):