code-context-control 2.139.0__tar.gz → 2.141.0__tar.gz

{code_context_control-2.139.0 → code_context_control-2.141.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.139.0
+Version: 2.141.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.139.0 → code_context_control-2.141.0}/cli/c3.py

@@ -91,7 +91,10 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.139.0"
+__version__ = "2.141.0"
+
+# The PreToolUse matcher for native subagent calls (installer and hub migration).
+AGENT_MATCHER = "Agent|Task"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -5078,7 +5081,7 @@ back to native tools as the task progresses.
 - **Filter**: `c3_filter(text=...)` — for terminal output >10 lines
 - **Shell**: `c3_shell(cmd, timeout=60)` — structured shell exec (tests/git/build). Auto-filters output, logs git mutations to the ledger. Native Bash for interactive/TTY only
 - **Memory**: `c3_memory(action='recall')` — full recall. `index` + `fetch` for token-efficient two-step retrieval
-- **Delegate**: `c3_delegate(task, task_type, context|file_path)` — your own provider one tier down (default `backend='host'`, `tier='small'`; Claude Code: Haiku) for bounded answers: summarize a diff/log, explain a function, triage a traceback. `scout=true` lets it look files up itself; `write_paths='a.py,b.py'` has Sonnet make a change you specified in only those files and return the diff. Multi-step work: the `c3-scout` (haiku) / `c3-worker` (sonnet) subagents
+- **Delegate**: `c3_delegate(task, task_type, context|file_path)` — your own provider one tier down (default `backend='host'`, `tier='small'`; Claude Code: Haiku) for bounded answers: summarize a diff/log, explain a function, triage a traceback. `scout=true` lets it look files up itself; `write_paths='a.py,b.py'` has Sonnet make a change you specified in only those files and return the diff. Multi-step work: the `c3-scout` (haiku) / `c3-worker` (sonnet) subagents; an `Agent` call with no `model` runs one tier below you (pass `model=` to choose)
 - **Local CI** (v2.79.0+): `c3_ci(action='inspect|run|rerun|failures')` — run THIS repo's real `.github/workflows` here instead of pushing for feedback. `run` executes in `needs` order; `failures` gives {file,line,message}; `rerun` retries only what failed. Only `FULL_CI_PASS` means safe to push — `PARTIAL_PASS` means something did not run (other OS, unsupported action, or your selection).
 - **Bitbucket** (v2.30.0+, when `c3 bitbucket login` has run): `c3_bitbucket(action='list_prs|get_pr|merge_pr|...')` — self-hosted Bitbucket Data Center / Server. Token in OS keyring; mutating actions auto-log to the edit ledger.
 - **Cross-project** (v2.31.0+): `c3_project(action='list|scan|search|read|edit|...', project='<name|path>')` — discover and operate on OTHER c3-installed projects. Reads run freely; writes (edit/shell/memory) need `allow_write=true`.
@@ -5697,6 +5700,10 @@ def cmd_install_mcp(args):
             shell_matcher,
             "run_shell_command",
         ]
+        # Native subagents (v2.140.0): a blank `model` is filled one tier below
+        # the parent by hook_agent_model — without this matcher PreToolUse
+        # never fires for Agent calls.
+        _pre_matcher_names.append(AGENT_MATCHER)
         desired_pre_hooks = [
             {"matcher": m, "hooks": [{"type": "command", "command": hook_pretool_cmd}]}
             for m in _pre_matcher_names

{code_context_control-2.139.0 → code_context_control-2.141.0}/cli/guide/tools.html

@@ -979,7 +979,7 @@ c3_delegate(task=<span class="str">'Rename calc_total to order_total in its defi
           <div class="callout callout-info">
             <span class="callout-icon">ℹ️</span>
             <div class="callout-body">
-              For multi-step work in Claude Code, <code>c3 install-mcp</code> also writes two subagents to <code>.claude/agents</code>: <code>c3-scout</code> (Haiku, read-only) and <code>c3-worker</code> (Sonnet). They run inside your session, so C3's hooks apply to them. Skip them with <code>--no-agents</code>. <code>c3 delegate-eval</code> measures pass rate and cost per backend and tier on your machine.
+              For multi-step work in Claude Code, <code>c3 install-mcp</code> also writes two subagents to <code>.claude/agents</code>: <code>c3-scout</code> (Haiku, read-only) and <code>c3-worker</code> (Sonnet). They run inside your session, so C3's hooks apply to them. Skip them with <code>--no-agents</code>. Any other <code>Agent</code> call that leaves <code>model</code> blank runs one tier below your session (Fable → Opus → Sonnet, never below Sonnet); set <code>delegate.agent_downshift</code> to <code>"off"</code> to keep the parent's model. When your own work looks delegable, a <code>[c3:delegate-hint]</code> line on the tool response names the call to make. <code>c3 delegate-eval</code> measures pass rate and cost per backend and tier on your machine.
             </div>
           </div>
         </div>

code_context_control-2.141.0/cli/hook_agent_model.py

@@ -0,0 +1,68 @@
+"""PreToolUse sub-hook: a native subagent with no ``model`` gets one tier below its parent.
+
+Routed by cli/hook_dispatch.py for ``Agent`` / ``Task`` on Claude Code only;
+the policy lives in services/agent_downshift.py. Returns
+``hookSpecificOutput.updatedInput`` (the whole tool_input with ``model`` set),
+or None to leave the call as it is. Every decision on a blank call — applied
+or not, and why — is one ``agent_downshift`` telemetry row, so coverage is
+measurable (how many calls fell through as ``parent_unknown``).
+
+Opt out per project with ``delegate.agent_downshift: "off"``, or for a shell
+with ``C3_AGENT_DOWNSHIFT=0``. Never raises into the tool call.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cli._hook_utils import find_project, log_hook_error  # noqa: E402
+
+
+def run(payload: dict, project_path: Path | None = None):
+    try:
+        return _run(payload, project_path)
+    except Exception as exc:  # a model choice is never worth a failed tool call
+        log_hook_error("hook_agent_model", exc)
+        return None
+
+
+def _run(payload: dict, project_path):
+    from services import agent_downshift as ad
+
+    if str(payload.get("tool_name") or "") not in ad.SUBAGENT_TOOLS:
+        return None
+    tool_input = payload.get("tool_input")
+    if not isinstance(tool_input, dict):
+        return None
+    if str(tool_input.get("model") or "").strip():
+        return None  # the caller chose
+    if os.environ.get("C3_AGENT_DOWNSHIFT", "").strip().lower() in ("0", "off", "false", "no"):
+        return None
+    project = find_project(payload, project_path)
+    if project is None:
+        return None
+    from core.config import load_delegate_config
+
+    cfg = load_delegate_config(str(project))
+    stype = str(tool_input.get("subagent_type") or "general-purpose")
+    if ":" in stype:
+        return None  # plugin agent: its definition is not ours to second-guess
+    if ad.definition_sets_model(stype, project):
+        return None
+    parent, source = ad.parent_model(payload, project)
+    target, reason = ad.resolve(stype, parent, cfg)
+    try:
+        from services.telemetry import append_telemetry_record
+        append_telemetry_record(project, {"tool": "agent_downshift" if target else "agent_downshift_skip",
+                                          "detail": {
+            "subagent_type": stype, "parent_model": parent, "parent_source": source,
+            "model": target, "reason": reason, "applied": bool(target)}})
+    except Exception:
+        pass
+    if not target:
+        return None
+    return {"hookSpecificOutput": {"hookEventName": "PreToolUse",
+                                   "updatedInput": {**tool_input, "model": target}}}

{code_context_control-2.139.0 → code_context_control-2.141.0}/cli/hook_dispatch.py

@@ -136,6 +136,10 @@ def _routes(event: str, raw_tool: str, norm_tool: str, host: str = HOST_CLAUDE):
         yield "hook_access_guard"
         # hook_pretool_enforce self-filters via its _PREREQS table.
         yield "hook_pretool_enforce"
+        # A native subagent with no model inherits the parent's; this fills
+        # one in (services/agent_downshift.py). Claude Code only.
+        if raw_tool in ("Agent", "Task") and host == HOST_CLAUDE:
+            yield "hook_agent_model"
     elif event == "posttool":
         # hook_filter is the ONE sub-hook that reads the whole tool payload:
         # it tiktoken-encodes the entire Bash output to measure savings, a
@@ -402,6 +406,7 @@ def merge_outputs(outputs: list, warnings: list, is_gemini: bool = False,
         host = HOST_GEMINI if is_gemini else HOST_CLAUDE
 
     deny_hso = None
+    updated_input = None
     contexts: list = []
     texts: list = []
     tool_result = None
@@ -413,6 +418,8 @@ def merge_outputs(outputs: list, warnings: list, is_gemini: bool = False,
         if isinstance(hso, dict):
             if deny_hso is None and hso.get("permissionDecision") == "deny":
                 deny_hso = hso
+            if updated_input is None and isinstance(hso.get("updatedInput"), dict):
+                updated_input = hso["updatedInput"]
             nested_ctx = hso.get("additionalContext")
             if nested_ctx and hso.get("permissionDecision") != "deny":
                 contexts.append(str(nested_ctx))
@@ -435,6 +442,10 @@ def merge_outputs(outputs: list, warnings: list, is_gemini: bool = False,
     result: dict = {}
     if deny_hso is not None:
         result["hookSpecificOutput"] = deny_hso
+    elif updated_input is not None and host == HOST_CLAUDE and event == "pretool":
+        # A rewritten tool input (hook_agent_model) — never alongside a deny.
+        result["hookSpecificOutput"] = {"hookEventName": "PreToolUse",
+                                        "updatedInput": updated_input}
     if tool_result is not None:
         if is_gemini:
             # Gemini has no tool_result replacement — degrade to context,

{code_context_control-2.139.0 → code_context_control-2.141.0}/cli/hub_server.py

@@ -2982,6 +2982,65 @@ def api_projects_enforcement_set():
     return jsonify(result)
 
 
+@app.route("/api/projects/enforcement/clear", methods=["POST"])
+def api_projects_enforcement_clear():
+    """Drop a scope's `enforcement` section so it inherits again.
+
+    Body: ``{path?, scope?}`` — same scope rules as the set route. There is
+    no mode a surface can WRITE that means "use the global default" (resolve
+    stops at the first section it finds), so "inherit" is a removal, and it
+    gets its own verb rather than a magic mode string. Nothing to clear is a
+    200 with ``cleared: false``: the caller asked for the state it is in.
+    Audited on the target project like a set.
+    """
+    from services import enforcement_policy as ep
+
+    data = request.get_json(silent=True) or {}
+    path = (data.get("path") or "").strip()
+    scope = (data.get("scope") or "project").strip().lower()
+    if scope not in ("project", "global"):
+        return jsonify({"error": "scope must be 'project' or 'global'"}), 400
+    if scope == "project":
+        if not path:
+            return jsonify({"error": "path is required for project scope"}), 400
+        try:
+            resolved = _resolve_project_path(path)
+        except ValueError as e:
+            return jsonify({"error": str(e)}), 404
+    else:
+        resolved = "."
+
+    try:
+        result = ep.clear(resolved, scope=scope)
+    except (ValueError, TypeError) as e:
+        return jsonify({"error": str(e)}), 400
+
+    if scope == "project" and result.get("cleared"):
+        detail = {"kind": "enforcement", "action": "clear",
+                  "previous": result.get("previous", ""),
+                  "mode": result.get("mode", ""), "scope": result.get("scope", ""),
+                  "via": "hub"}
+        summary = (f"tool discipline {result.get('previous') or 'default'} -> "
+                   f"inherit ({result.get('mode')} from {result.get('scope')}) "
+                   "via the Hub")
+        try:
+            from services.activity_log import ActivityLog
+            ActivityLog(resolved).log("access_action", dict(detail))
+        except Exception:
+            pass
+        try:
+            from services.edit_ledger import EditLedger
+            EditLedger(resolved).log_edit(
+                file="enforcement://project",
+                change_type="enforcement_clear",
+                summary=summary,
+                tags=["enforcement", "access"],
+                detail=detail)
+        except Exception:
+            pass
+    return jsonify(result)
+
+
 @app.route("/api/projects/enforcement/denials/search", methods=["GET"])
 def api_projects_enforcement_denials_search():
     """Search one project's raw denial events. Read-only; newest first.
@@ -3260,6 +3319,43 @@ def api_hub_override_costs():
                     "project": project_path})
 
 
+#: Verbatim from the spec, and the one thing a toggle screen must not let the
+#: reader forget: policy is a floor, not a promise.
+_OVERRIDE_POLICY_NOTE = (
+    "Project and global policy merge by tightening only: a layer is "
+    "escalatable iff both scopes allow it, and the numeric limits take "
+    "the smaller value."
+)
+
+
+def _hub_policy_audit(project_path: str, action: str, detail_extra: dict) -> None:
+    """One activity row + ledger entry per override-POLICY edit on the target.
+
+    Key names and the widening list only — never values of ``wake`` (an argv
+    this machine runs). A policy edit changes what a single tap can allow, so
+    a surface that can make it for many projects at once must leave a trail
+    on every one. Failure-safe.
+    """
+    detail = {"kind": "override_policy", "action": action, "via": "hub"}
+    detail.update(detail_extra or {})
+    widened = detail.get("widened") or []
+    summary = (f"override policy {action} via the Hub"
+               + (f" (widened: {', '.join(widened)})" if widened else ""))
+    try:
+        from services.activity_log import ActivityLog as _AL
+        _AL(str(project_path)).log("access_action", dict(detail))
+    except Exception:
+        pass
+    try:
+        from services.edit_ledger import EditLedger
+        EditLedger(str(project_path)).log_edit(
+            file="override://policy",
+            change_type=f"override_policy_{action}",
+            summary=summary, tags=["override", "policy"], detail=dict(detail))
+    except Exception:
+        pass
+
+
 @app.route("/api/hub/overrides/policy", methods=["GET"])
 def api_hub_override_policy_get():
     """The effective `override` section for one project.
@@ -3289,13 +3385,7 @@ def api_hub_override_policy_get():
         "layers": list(opol.LAYER_KEYS),
         "typed_confirm_layers": sorted(opol.TYPED_CONFIRM_LAYERS),
         "hard_max_ttl_s": opol.HARD_MAX_TTL_S,
-        # Verbatim from the spec, and the one thing a toggle screen must not
-        # let the reader forget: policy is a floor, not a promise.
-        "coverage_note": (
-            "Project and global policy merge by tightening only: a layer is "
-            "escalatable iff both scopes allow it, and the numeric limits take "
-            "the smaller value."
-        ),
+        "coverage_note": _OVERRIDE_POLICY_NOTE,
     })
 
 
@@ -3334,11 +3424,107 @@ def api_hub_override_policy_set():
         return jsonify(exc.payload), exc.status
     except (OSError, ValueError) as exc:
         return jsonify({"error": f"{type(exc).__name__}: {exc}"}), 500
+    section = data.get("override") or {}
+    keys = [k for k in section if k != "layers"]
+    keys += [f"layers.{k}" for k in (section.get("layers") or {})]
+    _hub_policy_audit(project_path, "set",
+                      {"keys": sorted(keys), "widened": list(widens)})
     return jsonify({"path": project_path, "written": written,
                     "policy": opol.resolve(project_path).as_dict(),
                     "widened": widens})
 
 
+@app.route("/api/hub/overrides/policy/overview", methods=["GET"])
+def api_hub_override_policy_overview():
+    """Every registered project's effective override policy in one call.
+
+    The cross-project read a bulk editor needs (C3 Desk's Rules view), shaped
+    like the enforcement overview: per-row isolation, so one unreadable
+    project reports ``error`` instead of blanking the page, and a corrupt
+    section is reported as corrupt rather than as the disabled policy it
+    resolves to. ``project_keys`` names what the project pins itself, so a
+    screen can tell an inherited value from a chosen one. The global scope is
+    served READ-ONLY: ``write_section`` is project-scope by design.
+    """
+    from services import override_policy as opol
+
+    rows = []
+    for p in _pm().list_projects():
+        ppath = str(p.get("path") or "")
+        row = {"name": p.get("name") or Path(ppath).name, "path": ppath,
+               "initialized": True, "error": None, "policy": None,
+               "configured": False, "corrupt": False, "project_keys": []}
+        try:
+            if not (Path(ppath) / ".c3").is_dir():
+                row["initialized"] = False
+            else:
+                keys, present, corrupt = opol.scope_keys(ppath)
+                row["project_keys"] = keys
+                row["configured"] = present
+                row["corrupt"] = corrupt
+                row["policy"] = opol.resolve(ppath).as_dict()
+        except Exception as e:
+            row["error"] = str(e)
+        rows.append(row)
+
+    try:
+        keys, present, corrupt = opol.global_scope_keys()
+        global_policy = {"configured": present, "corrupt": corrupt,
+                         "keys": keys, "error": None,
+                         "policy": opol.resolve_global().as_dict()}
+    except Exception as e:
+        global_policy = {"configured": False, "corrupt": False, "keys": [],
+                         "error": str(e), "policy": None}
+
+    return jsonify({
+        "projects": rows,
+        "global_policy": global_policy,
+        "defaults": {k: v for k, v in opol.DEFAULTS.items()
+                     if k != opol.WAKE_KEY},
+        "layers": list(opol.LAYER_KEYS),
+        "typed_confirm_layers": sorted(opol.TYPED_CONFIRM_LAYERS),
+        "hard_max_ttl_s": opol.HARD_MAX_TTL_S,
+        "coverage_note": _OVERRIDE_POLICY_NOTE,
+        # What this Hub can do beyond the per-project GET/POST, so a client
+        # built against a newer C3 can hide what an older one cannot serve.
+        "features": ["clear"],
+    })
+
+
+@app.route("/api/hub/overrides/policy/clear", methods=["POST"])
+def api_hub_override_policy_clear():
+    """Drop one project's own `override` opinions so it inherits global.
+
+    Body: ``{path, confirm?}``. Clearing can LOOSEN (the project may have
+    been tighter than global), so it goes through the same widening check as
+    a set and needs ``confirm: "widen"`` when it does. ``wake`` survives the
+    clear. A corrupt project section is 409: it needs a human, not a reset.
+    """
+    from services import override_policy as opol
+    data = request.get_json(silent=True) or {}
+    raw = (data.get("path") or "").strip()
+    if not raw:
+        return jsonify({"error": "path is required"}), 400
+    try:
+        project_path = str(_resolve_project_path(raw))
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 404
+    try:
+        kept, widens = opol.clear_section(
+            project_path, confirmed=(data.get("confirm") == "widen"))
+    except opol.PolicyEditError as exc:
+        return jsonify(exc.payload), exc.status
+    except (OSError, ValueError) as exc:
+        return jsonify({"error": f"{type(exc).__name__}: {exc}"}), 500
+    cleared = kept is not None
+    if cleared:
+        _hub_policy_audit(project_path, "clear",
+                          {"kept": sorted(kept), "widened": list(widens)})
+    return jsonify({"path": project_path, "cleared": cleared,
+                    "policy": opol.resolve(project_path).as_dict(),
+                    "widened": widens})
+
+
 @app.route("/api/hub/overrides/<request_id>", methods=["POST"])
 def api_hub_override_decide(request_id):
     """Approve (minting a grant) or deny one request. decided_by='desktop'.
@@ -4516,9 +4702,16 @@ def c3_hook_migrations(cli_dir: Path | None = None) -> list:
                                  "command": f"{dispatch} {arg}"}]},
         }
 
+    # v2.140.0: native subagent calls reach the pretool dispatcher, where
+    # hook_agent_model fills a blank model. Same literal as cli.c3.AGENT_MATCHER.
+    agent_entry = {"matcher": "Agent|Task",
+                   "hooks": [{"type": "command", "command": f"{dispatch} pretool"}]}
+
     return [
         {"settings": ".claude/settings.local.json", "event": "PostToolUse",
          "present": c3read_present, "entry": c3read_entry},
+        {"settings": ".claude/settings.local.json", "event": "PreToolUse",
+         "present": _has_matcher("Agent|Task"), "entry": agent_entry},
         {"settings": ".gemini/settings.json", "event": "AfterTool",
          "present": c3read_present, "entry": c3read_entry},
         # Claude only — Gemini has no session-lifecycle event to hang these on.

{code_context_control-2.139.0 → code_context_control-2.141.0}/cli/mcp_server.py

@@ -25,6 +25,7 @@ from fastmcp import Context, FastMCP
 
 from core.host import resolve_host
 from core.ide import get_profile
+from services import delegate_hints
 from services.auto_memory import AutoMemory
 from services.context_snapshot import ContextSnapshot
 from services.runtime import C3Runtime, build_runtime, start_runtime, stop_runtime
@@ -515,6 +516,21 @@ _last_badge_count: int = 0  # delta-based: only show badge when count increases
 _finalize_lock = threading.Lock()
 
 
+def _with_hint(resp, make_hint) -> str:
+    """``resp`` plus a delegation hint line (services/delegate_hints), when the
+    call succeeded and a hint is due. A hint is advice: it never fails a call."""
+    if not isinstance(resp, str):
+        return resp
+    try:
+        from cli._hook_utils import response_text_failed
+        if response_text_failed(resp):
+            return resp
+        hint = make_hint()
+    except Exception:
+        return resp
+    return f"{resp}\n{hint}" if hint else resp
+
+
 def _finalize_response(ctx: Context, tool_name: str, args: dict,
                        response: str, summary: str = "",
                        response_tokens: int = 0) -> str:
@@ -668,10 +684,11 @@ async def c3_search(query: str, action: str = "code", top_k: int = 3,
     def finalize(name, args, resp, summ, **kw):
         return _finalize_response(ctx, name, args, resp, summ, **kw)
 
-    return await asyncio.to_thread(handle_search, query, action, top_k, max_tokens, svc,
+    resp = await asyncio.to_thread(handle_search, query, action, top_k, max_tokens, svc,
                                    finalize, maybe_related_facts, prefetch=prefetch,
                                    scope=scope, ignore_case=ignore_case,
                                    path=path, lang=lang, kind=kind)
+    return _with_hint(resp, lambda: delegate_hints.after_read(svc, ""))
 
 
 @mcp.tool()
@@ -746,7 +763,10 @@ async def c3_read(file_path: str, symbols: Any = None, lines: Any = None,
     def finalize(name, args, resp, summ, **kw):
         return _finalize_response(ctx, name, args, resp, summ, **kw)
 
-    return await asyncio.to_thread(handle_read, file_path, symbols, lines, include_docstrings, svc, finalize)
+    resp = await asyncio.to_thread(handle_read, file_path, symbols, lines, include_docstrings, svc, finalize)
+    if not (symbols or lines):
+        return resp  # a map is the cheap way to look; it does not count toward the hint
+    return _with_hint(resp, lambda: delegate_hints.after_read(svc, file_path.split(",")[0].strip()))
 
 
 # c3_compress left the MCP surface in 2.124.0: c3_read(file_path) serves the
@@ -827,6 +847,10 @@ async def c3_delegate(task: str, task_type: str = "ask", context: str = "",
             task.add_done_callback(lambda done: done.exception() if not done.cancelled() else None)
         loop.call_soon_threadsafe(schedule)
     svc._agent_progress_cb = _progress_cb
+    try:
+        delegate_hints.after_delegate(svc, write=bool(str(write_paths or "").strip()), scout=bool(scout))
+    except Exception:
+        pass
     try:
         return await asyncio.to_thread(handle_delegate, task, task_type, context,
                                        file_path, svc, finalize, backend,
@@ -879,8 +903,10 @@ async def c3_edit(file_path: str, old_string: str = "", new_string: str = "",
     def finalize(name, args, resp, summ, **kw):
         return _finalize_response(ctx, name, args, resp, summ, **kw)
 
-    return await asyncio.to_thread(handle_edit, file_path, old_string, new_string,
+    resp = await asyncio.to_thread(handle_edit, file_path, old_string, new_string,
                                    summary, tags, replace_all, svc, finalize, edits)
+    return _with_hint(resp, lambda: delegate_hints.after_edit(
+        svc, file_path, delegate_hints.edit_chars(new_string, edits)))
 
 
 @mcp.tool()

{code_context_control-2.139.0 → code_context_control-2.141.0}/cli/tools/status.py

@@ -121,7 +121,18 @@ def _budget_view(svc, detailed, finalize):
     # (2.132.0+): how much work went one tier down, where, and what it cost.
     try:
         from services.telemetry import aggregate_tool_telemetry
-        rows = aggregate_tool_telemetry(svc.project_path, days=7).get("delegate_by_backend") or {}
+        agg7 = aggregate_tool_telemetry(svc.project_path, days=7)
+        by_tool = agg7.get("by_tool") or {}
+
+        def _n(tool: str) -> int:
+            return int((by_tool.get(tool) or {}).get("calls") or 0)
+
+        moved, blank = _n("agent_downshift"), _n("agent_downshift") + _n("agent_downshift_skip")
+        hints, followed = _n("delegate_hint"), _n("delegate_hint_followed")
+        if blank or hints:
+            lines.append(f"[delegate-auto:7d] {moved} of {blank} model-less subagent call(s) moved to a "
+                         f"lower model, {hints} delegation hint(s) shown, {followed} followed")
+        rows = agg7.get("delegate_by_backend") or {}
         used = sorted(((k, r) for k, r in rows.items() if r.get("calls")), key=lambda kv: -kv[1]["calls"])
         if used:
             calls = sum(r["calls"] for _k, r in used)

{code_context_control-2.139.0 → code_context_control-2.141.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.139.0
+Version: 2.141.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.139.0 → code_context_control-2.141.0}/code_context_control.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ cli/c3.py
 cli/docs.html
 cli/edits.html
 cli/hook_access_guard.py
+cli/hook_agent_model.py
 cli/hook_artifact.py
 cli/hook_auto_snapshot.py
 cli/hook_c3_signal.py
@@ -194,6 +195,7 @@ services/access_guard.py
 services/access_telemetry.py
 services/activity_log.py
 services/agent_base.py
+services/agent_downshift.py
 services/agent_locks.py
 services/agents.py
 services/agents_workflow.py
@@ -225,6 +227,7 @@ services/cred_audit.py
 services/cred_telemetry.py
 services/credential_store.py
 services/delegate_agents.py
+services/delegate_hints.py
 services/delegate_write.py
 services/dir_map.py
 services/doc_index.py
@@ -363,6 +366,7 @@ tests/test_credentials_routes.py
 tests/test_credentials_tool.py
 tests/test_creds_cli_smoke.py
 tests/test_delegate_adoption_d4.py
+tests/test_delegate_auto.py
 tests/test_delegate_cascade.py
 tests/test_delegate_claude_d1.py
 tests/test_delegate_eval.py
@@ -414,6 +418,7 @@ tests/test_hub_locks_routes.py
 tests/test_hub_oracle_service_routes.py
 tests/test_hub_override_policy_routes.py
 tests/test_hub_override_routes.py
+tests/test_hub_rules_routes.py
 tests/test_hub_server_smoke.py
 tests/test_hub_subproject_links.py
 tests/test_ide_workflow_adaptation.py

{code_context_control-2.139.0 → code_context_control-2.141.0}/core/config.py

@@ -316,6 +316,15 @@ DELEGATE_DEFAULTS = {
                                           # (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
+    # Native Claude Code subagents (docs/delegate-auto.md). An Agent call with no model runs
+    # on the parent's model; the PreToolUse hook fills one in.
+    "agent_downshift": "one_down",        # one_down | off | a fixed alias (haiku/sonnet/opus)
+    "agent_downshift_floor": "sonnet",    # never below this (Haiku flailed on lookups, missed subtle specs)
+    "agent_downshift_skip": ["fork", "Plan"],  # subagent types left on the parent's model
+    "agent_models": {},                   # {subagent_type: alias} explicit per-type choice
+    # Delegation hints: one line on a c3_* response when the session's own work looks delegable.
+    "hints": True,
+    "hint_cooldown_minutes": 45,          # per hint kind
 }
 
 

{code_context_control-2.139.0 → code_context_control-2.141.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.139.0"
+version = "2.141.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"