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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.139.0
+Version: 2.140.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.140.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.140.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.140.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.140.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.140.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.140.0}/cli/hub_server.py

@@ -4516,9 +4516,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.140.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.140.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.140.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.140.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.140.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

{code_context_control-2.139.0 → code_context_control-2.140.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.140.0}/pyproject.toml

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

@@ -0,0 +1,220 @@
+"""Give a native Claude Code subagent a model when the caller left it blank.
+
+Measured 2026-09-14 over ~/.claude/projects transcripts since 2026-07-01: 963
+of 991 ``Agent`` calls had no ``model``, and on Claude Code 2.1.270 such a call
+runs on the PARENT's model — ``Explore`` included (a probe with a Sonnet parent
+put all of an Explore run on Sonnet). So a Fable or Opus session pays its own
+rate for every search-and-summarise branch it spawns.
+
+The same probe proved the lever: a PreToolUse *command* hook that returns
+``hookSpecificOutput.updatedInput`` with ``model`` set changes the model the
+subagent runs on (``opus`` appeared in ``modelUsage`` only with the hook).
+
+Policy (``resolve``), all from ``.c3/config.json → delegate``:
+
+- ``agent_downshift``: ``"one_down"`` (default) — one tier below the parent,
+  Fable → Opus → Sonnet; ``"off"``; or a fixed alias (``"sonnet"``) used only
+  when it is below the parent.
+- ``agent_downshift_floor``: ``"sonnet"``. Never below it: on the delegate
+  evals Haiku took 28 turns where Sonnet took 8 on a lookup, and missed
+  subtle specs Sonnet got right. So a Sonnet parent is left alone.
+- ``agent_downshift_skip``: ``["fork", "Plan"]``. A fork ignores ``model``;
+  planning is where the parent's strength is the point.
+- ``agent_models``: ``{subagent_type: alias}`` — an explicit per-type choice,
+  applied whenever it is below the parent (or the parent is unknown).
+
+Never touched: a call that names a model, and a subagent whose definition
+(``.claude/agents/*.md``, project or user) sets ``model:``. Plugin agents
+(``plugin:name``) are left alone — their definitions are not ours to read.
+
+The parent model is not in any hook payload (checked: SessionStart,
+UserPromptSubmit and PreToolUse carry none). It is read from the transcript
+(the last assistant row's ``message.model``), else the last model this project
+saw in the past 14 days, else Claude settings' ``model``; unknown means no
+change.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+TIERS = ("haiku", "sonnet", "opus", "fable")  # cheapest first
+SUBAGENT_TOOLS = ("Agent", "Task")
+DEFAULT_SKIP = ("fork", "Plan")
+STATE_FILE = "agent_downshift_state.json"
+_STATE_MAX_AGE = timedelta(days=14)
+_TRANSCRIPT_TAIL = 512_000
+
+
+def rank(model) -> int | None:
+    """0 haiku … 3 fable, from an alias or a full id; None when not a tier."""
+    m = str(model or "").strip().lower()
+    for i in range(len(TIERS) - 1, -1, -1):
+        if TIERS[i] in m:
+            return i
+    return None
+
+
+def _alias(value) -> str:
+    """The Agent tool's alias for a tier name or a full model id."""
+    r = rank(value)
+    return TIERS[r] if r is not None else ""
+
+
+def resolve(subagent_type: str, parent_model: str, cfg: dict) -> tuple[str, str]:
+    """``(alias_or_empty, reason)`` for one Agent call with no ``model``."""
+    mode = str(cfg.get("agent_downshift", "one_down") or "off").strip().lower()
+    if mode in ("off", "false", "0", "none", "inherit"):
+        return "", "off"
+    stype = str(subagent_type or "general-purpose")
+    skip = cfg.get("agent_downshift_skip")
+    skip = list(DEFAULT_SKIP) if skip is None else [str(s) for s in skip]
+    if stype in skip:
+        return "", "skipped_type"
+    parent = rank(parent_model)
+    overrides = cfg.get("agent_models") or {}
+    if isinstance(overrides, dict) and stype in overrides:
+        target = _alias(overrides[stype])
+        if not target:
+            return "", "override_inherit"
+        if parent is not None and rank(target) >= parent:
+            return "", "not_a_downshift"
+        return target, "override"
+    if parent is None:
+        return "", "parent_unknown"
+    if mode == "one_down":
+        wanted = parent - 1
+    else:
+        fixed = _alias(mode)
+        if not fixed:
+            return "", "bad_config"
+        wanted = rank(fixed)
+    floor = rank(_alias(cfg.get("agent_downshift_floor", "sonnet")) or "sonnet")
+    wanted = max(wanted, floor)
+    if wanted >= parent:
+        return "", "at_floor"
+    return TIERS[wanted], mode if mode != "one_down" else "one_down"
+
+
+# ── Parent model ────────────────────────────────────────────────────────────
+
+
+def transcript_model(path) -> str:
+    """The model of the latest assistant row in a Claude Code transcript."""
+    try:
+        p = Path(str(path))
+        size = p.stat().st_size
+        with open(p, "rb") as fh:
+            if size > _TRANSCRIPT_TAIL:
+                fh.seek(size - _TRANSCRIPT_TAIL)
+            tail = fh.read().decode("utf-8", errors="replace")
+    except (OSError, ValueError):
+        return ""
+    for line in reversed(tail.splitlines()):
+        if '"model"' not in line:
+            continue
+        try:
+            row = json.loads(line)
+        except ValueError:
+            continue
+        msg = row.get("message") if isinstance(row, dict) else None
+        model = msg.get("model") if isinstance(msg, dict) else None
+        if row.get("type") == "assistant" and rank(model) is not None:
+            return str(model)
+    return ""
+
+
+def _state_path(project) -> Path:
+    return Path(project) / ".c3" / STATE_FILE
+
+
+def remember_parent(project, model: str) -> None:
+    try:
+        path = _state_path(project)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(f".{os.getpid()}.tmp")
+        tmp.write_text(json.dumps({"last_parent_model": model,
+                                   "seen_at": datetime.now(timezone.utc).isoformat()}), encoding="utf-8")
+        os.replace(tmp, path)
+    except OSError:
+        pass
+
+
+def _remembered(project) -> str:
+    try:
+        data = json.loads(_state_path(project).read_text(encoding="utf-8"))
+        seen = datetime.fromisoformat(str(data.get("seen_at")))
+        if datetime.now(timezone.utc) - seen <= _STATE_MAX_AGE:
+            return str(data.get("last_parent_model") or "")
+    except (OSError, ValueError, TypeError):
+        pass
+    return ""
+
+
+def _settings_model(project) -> str:
+    for p in (Path(project) / ".claude" / "settings.local.json", Path(project) / ".claude" / "settings.json",
+              Path.home() / ".claude" / "settings.json"):
+        try:
+            model = json.loads(p.read_text(encoding="utf-8")).get("model")
+        except (OSError, ValueError, AttributeError):
+            continue
+        if rank(model) is not None:
+            return str(model)
+    return ""
+
+
+def parent_model(payload: dict, project) -> tuple[str, str]:
+    """``(model, source)``: transcript, remembered, settings, or ('', 'unknown')."""
+    model = transcript_model(payload.get("transcript_path") or "")
+    if model:
+        remember_parent(project, model)
+        return model, "transcript"
+    model = _remembered(project)
+    if model:
+        return model, "remembered"
+    model = _settings_model(project)
+    if model:
+        return model, "settings"
+    return "", "unknown"
+
+
+# ── Agent definitions ───────────────────────────────────────────────────────
+
+
+def _frontmatter(text: str) -> dict:
+    if not text.startswith("---"):
+        return {}
+    end = text.find("\n---", 3)
+    if end < 0:
+        return {}
+    out = {}
+    for line in text[3:end].splitlines():
+        key, sep, value = line.partition(":")
+        if sep:
+            out[key.strip().lower()] = value.strip().strip("'\"")
+    return out
+
+
+def definition_sets_model(subagent_type: str, project) -> bool:
+    """True when a project or user agent definition for this type pins a model."""
+    name = str(subagent_type or "")
+    if not name:
+        return False
+    for folder in (Path(project) / ".claude" / "agents", Path.home() / ".claude" / "agents"):
+        try:
+            files = sorted(folder.glob("*.md"))
+        except OSError:
+            continue
+        for f in files:
+            try:
+                meta = _frontmatter(f.read_text(encoding="utf-8", errors="replace"))
+            except OSError:
+                continue
+            if (meta.get("name") or f.stem) != name:
+                continue
+            model = meta.get("model", "").strip().lower()
+            return bool(model) and model != "inherit"
+    return False

{code_context_control-2.139.0 → code_context_control-2.140.0}/services/claude_md.py

@@ -39,7 +39,7 @@ When falling back, state which c3_* tool was attempted and why it was insufficie
 6.5. **SHELL via C3**: `c3_shell(cmd, cwd='', timeout=60)` — for tests, git, build, scripts. Returns structured `{exit_code, stdout, stderr, duration_ms}`. Auto-filters stdout >30 lines; auto-logs git-mutating commands (commit/add/merge/rebase/reset/restore/checkout) to the edit ledger. Best-effort blocks the most catastrophic commands (`rm -rf` of `/`, a top-level system dir, or `$HOME`/`~`; fork bombs; whole-drive wipes) — a guard, not a sandbox; soft-warns on `--force`, `--no-verify`, `reset --hard`. Native Bash remains the fallback for interactive/TTY commands
 7. **VALIDATE**: `c3_validate(file_path)` — after edits or before reporting done. Runs deep type check (pyright/tsc) automatically if installed
 8. **LOG**: `c3_session(action='log')` for decisions. `c3_session(action='snapshot')` before /clear
-9. **DELEGATE** (one tier down, same provider): `c3_delegate(task, task_type, context|file_path)` — default `backend='host'` runs your own provider at `tier='small'` (Claude Code: Haiku; `medium`=Sonnet). Use it for bounded work whose answer is a few lines: summarize a diff or log, explain a function, triage a traceback, draft a docstring or test cases. `scout=true` lets it Read/Grep/Glob the project itself for lookups. `write_paths='a.py,b.py'` hands a change you have already specified to Sonnet: it edits only those paths and returns the diff for you to review and test. Multi-step work in Claude Code: the `c3-scout` (haiku, read-only) and `c3-worker` (sonnet) subagents. `c3_agent(workflow=...)` for multi-model pipelines
+9. **DELEGATE** (one tier down, same provider): `c3_delegate(task, task_type, context|file_path)` — default `backend='host'` runs your own provider at `tier='small'` (Claude Code: Haiku; `medium`=Sonnet). Use it for bounded work whose answer is a few lines: summarize a diff or log, explain a function, triage a traceback, draft a docstring or test cases. `scout=true` lets it Read/Grep/Glob the project itself for lookups. `write_paths='a.py,b.py'` hands a change you have already specified to Sonnet: it edits only those paths and returns the diff for you to review and test. Multi-step work in Claude Code: the `c3-scout` (haiku, read-only) and `c3-worker` (sonnet) subagents; an `Agent` call with no `model` runs one tier below you (Fable→Opus→Sonnet, C3 hook) — pass `model=` to choose. A `[c3:delegate-hint]` line means the work you are doing now is delegable. `c3_agent(workflow=...)` for multi-model pipelines
 9.5. **LOCAL CI** (v2.79.0+): `c3_ci(action='inspect|run|rerun|status|failures|logs|runs')` — run THIS repository's real `.github/workflows/*.yml` on this machine instead of pushing to find out. C3 reads the existing workflow files; it does NOT define a second CI config. `inspect` shows the job DAG and which jobs are runnable on this host; `run` executes in `needs` order and SKIPS (never passes) a job whose dependency failed; `failures` returns `{file,line,message}` instead of raw logs; `rerun` retries only what failed. VERDICTS: `FULL_CI_PASS` means every job ran HERE and passed — the only one that means safe to push. `PARTIAL_PASS` means something did not run (targets another OS, uses an action C3 cannot execute, or you selected a subset) and is NOT a green light. Jobs targeting another OS are refused unless `allow_foreign=true`, which labels the result cross-OS and can never yield FULL_CI_PASS. ENGINES (v2.81.0+): `native` runs jobs matching this host; `act` runs Linux jobs in a real container (real `uses:` actions included) when act+Docker are installed — `c3_ci(action='doctor')` reports what is available. A container run DOES count toward FULL_CI_PASS; a cross-OS one never does. macOS jobs cannot run locally on any engine. Jobs that look like they publish or deploy are refused unless allow_side_effects=true, and C3 never passes secrets to act. See docs/agent-ci.md.
 10. **BITBUCKET** (when configured, v2.30.0+): `c3_bitbucket(action='...')` — for self-hosted enterprise Bitbucket Data Center / Server: PRs, branches, builds, repo admin. Tokens live in the OS keyring (set up via `c3 bitbucket login`, or `login --global` for a home config reusable across projects; account resolution precedence is project → home). Read actions are safe in plan mode; write actions (`merge_pr`, `create_branch`, etc.) are auto-logged to the edit ledger.
 10.5. **JIRA** (when configured, v2.56.0+): `c3_jira(action='...')` — Jira Cloud + Data Center: `search` (raw JQL), `my_issues`, `get_issue`, `list_transitions`, `get_create_metadata`, `search_users`, `list_link_types`, `list_boards`, `list_sprints`, `list_worklogs` reads; `create_issue` / `update_issue` / `comment` / `transition` / `assign` / `link_issues` / `unlink_issues` / `move_to_sprint` / `move_to_backlog` / `add_worklog` / `attach_file` / `delete_issue` (permanent; refuses subtask-bearing issues unless delete_subtasks=true) mutations auto-logged to the edit ledger (identifiers only, never bodies). createmeta reflects the issue type's field configuration, NOT the create screen — if create_issue rejects a listed field ('not on the appropriate screen'), create without it, then set it via `update_issue`. Epic membership: pass `parent=<EPIC-KEY>` to create_issue/update_issue ('none' clears) — C3 maps it per deployment (Cloud `parent` field vs Data Center Epic Link customfield); `link_issues(issue, link_type, target)` creates typed links reading '<issue> <link_type> <target>' (types via `list_link_types`). Sprints: `list_boards` → `list_sprints(board_id)` → `move_to_sprint(issue, sprint_id)`; `attach_file(issue, file_path)` uploads a local file as evidence. Tokens in the OS keyring (`c3 jira login`, or `login --global` for cross-project reuse; the jira config section resolves project → home wholesale from one file — never field-merged). Read actions are safe in plan mode.