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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.138.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.138.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.138.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):
@@ -1583,6 +1586,19 @@ def cmd_delegate_eval(args):
 
     targets = [t.strip() for t in (args.targets or "").split(",") if t.strip()]
     case_ids = [c.strip() for c in (args.cases or "").split(",") if c.strip()]
+    if args.suite == "write":
+        # Write mode (docs/delegate-write.md): graded on the files left behind.
+        from services.bench import delegate_write_eval as dwe
+        if not targets:
+            raise RuntimeError("--suite write needs --targets (e.g. claude:small,claude:medium, or gold)")
+        try:
+            overrides = json.loads(args.config) if getattr(args, "config", None) else None
+            report = dwe.run_write_suite(targets, case_ids=case_ids or None, record=args.record,
+                                         delegate_overrides=overrides)
+        except ValueError as e:
+            raise RuntimeError(str(e))
+        print(json.dumps(report, indent=2) if args.json else dwe.render(report))
+        return
     overrides = json.loads(args.config) if getattr(args, "config", None) else None
     if overrides is not None and not isinstance(overrides, dict):
         raise RuntimeError("--config must be a JSON object")
@@ -5065,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. 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`.
@@ -5684,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.138.0 → code_context_control-2.140.0}/cli/commands/parser.py

@@ -92,7 +92,8 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_delegate_eval = subparsers.add_parser(
         "delegate-eval", help="Grade c3_delegate answers per backend/tier (docs/delegate-eval.md)")
     p_delegate_eval.add_argument("--suite", default="gold",
-                                 help="'gold' (bundled) or a .jsonl path")
+                                 help="'gold' (bundled), 'write' (write mode, docs/delegate-write.md) "
+                                      "or a .jsonl path")
     p_delegate_eval.add_argument("--targets", default="",
                                  help="Comma-separated backend[:tier] list, e.g. 'claude:small,claude:medium'")
     p_delegate_eval.add_argument("--cases", default="", help="Comma-separated case ids (default: all)")

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

@@ -954,6 +954,12 @@ c3_status(view=<span class="str">'sessions'</span>)         <span class="com">#
                 <td class="param-default">false</td>
                 <td class="param-desc">Let the delegate Read/Grep/Glob the project itself, for lookups when you cannot name the files. Claude runs <code>--restricted</code> with Access Guard's read denies; Codex uses its read-only sandbox.</td>
               </tr>
+              <tr>
+                <td class="param-name">write_paths</td>
+                <td class="param-type">string</td>
+                <td class="param-default">""</td>
+                <td class="param-desc">Write mode (Claude only, defaults to Sonnet). Comma-separated project-relative globs the delegate may edit or create. You decide the change; it makes it with Read/Grep/Glob/Edit/Write, no commands. You get back the diff, and each change is in the edit ledger. Access Guard applies; confirm-held, locked, <code>.git/</code> and <code>.c3/</code> paths are refused. Review the diff and run the tests yourself.</td>
+              </tr>
             </tbody>
           </table>
 
@@ -965,12 +971,15 @@ c3_delegate(task=<span class="str">'Summarize this diff for a changelog in three
 c3_delegate(task=<span class="str">'What does resolve_host return inside a grok child?'</span>, file_path=<span class="str">'core/host.py'</span>, task_type=<span class="str">'explain'</span>, tier=<span class="str">'medium'</span>)
 
 <span class="com"># A lookup the delegate does itself</span>
-c3_delegate(task=<span class="str">'Which functions call charge_card, and where?'</span>, scout=<span class="kw">True</span>)</code></pre>
+c3_delegate(task=<span class="str">'Which functions call charge_card, and where?'</span>, scout=<span class="kw">True</span>)
+
+<span class="com"># A change you have decided, made by Sonnet inside a write set</span>
+c3_delegate(task=<span class="str">'Rename calc_total to order_total in its definition and every use; no alias'</span>, write_paths=<span class="str">'inv/orders.py, inv/report.py, tests/test_orders.py'</span>)</code></pre>
 
           <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.138.0 → code_context_control-2.140.0}/cli/hook_access_guard.py

@@ -503,14 +503,77 @@ def run(payload: dict, project_path: Path | None = None,
     return None
 
 
+def _worker_refusal(rel: str, why: str) -> dict:
+    return _deny(f"[c3-delegate:refused] {rel}: {why}. Do not write it another way; "
+                 "leave it and say in your report what change it needed.")
+
+
+def worker_run(payload: dict, project_path: Path, state_dir: Path) -> dict | None:
+    """PreToolUse for a ``c3_delegate`` write-mode worker (see services/delegate_write).
+
+    Reads go through ``run`` exactly as for a scout. A write must pass, in
+    order: canonicalization inside the project, never ``.git/`` or ``.c3/``,
+    never the credential vault, Access Guard with NO grants and NO filed
+    requests (a confirm hold is a refusal here — a headless worker cannot
+    wait for a human, and the caller can make that edit itself), the caller's
+    write set, and another agent's lock. Then the pre-image is saved before
+    the write is allowed. Raises on a broken spec; main() turns that into a
+    deny.
+    """
+    from services import delegate_write as dw
+
+    tool = normalize_tool_name(payload.get("tool_name", ""))
+    if tool not in _WRITE_TOOLS:
+        return run(payload, project_path)
+    spec = dw.load_spec(state_dir)
+    fp = _target(payload.get("tool_input", {}) or {})
+    if not fp:
+        return _deny("[c3-delegate:refused] a write with no target path")
+    base = str(project_path)
+    canon, rel, denial = ag.canonicalize(fp, base)
+    if denial:
+        return _worker_refusal(fp, f"path refused ({denial.reason})")
+    if not rel:
+        return _worker_refusal(fp, "outside the project")
+    if dw.forbidden(rel):
+        return _worker_refusal(rel, "under .git/ or .c3/, never delegate-writable")
+    try:
+        from services import credential_store as _cs
+        vault = _cs.vault_guard_reason(fp)
+    except Exception as exc:  # fail closed: an unloadable vault check refuses
+        vault = f"vault check unavailable ({type(exc).__name__})"
+    if vault:
+        return _worker_refusal(rel, "credential vault file")
+    op = "write" if os.path.exists(fp) else "create"
+    denial = ag.check(fp, op, base)
+    if denial:
+        _record(denial, tool, op, fp, base, str(payload.get("session_id") or ""))
+        return _worker_refusal(rel, f"Access Guard {denial.kind} rule '{denial.rule}' "
+                                    f"({denial.scope})")
+    if not dw.in_write_set(rel, spec["write_paths"]):
+        return _worker_refusal(rel, "outside the write set the caller gave ("
+                                    + ", ".join(spec["write_paths"]) + ")")
+    try:
+        from services import agent_locks
+        holder = agent_locks.check(fp, base, str(spec.get("session_id") or ""))
+    except Exception:
+        holder = None
+    if holder:
+        return _worker_refusal(rel, f"locked by {holder.get('agent_id', 'another agent')}")
+    dw.snapshot(state_dir, fp, canon)
+    return None
+
+
 def main() -> None:
-    """Standalone PreToolUse entry for a ``c3_delegate`` scout run.
+    """Standalone PreToolUse entry for a ``c3_delegate`` scout or worker run.
 
     A scout is ``claude -p --restricted`` with Read/Grep/Glob and no C3 MCP
     server, so the dispatcher's discipline hook (hook_pretool_enforce) would
     refuse every native read. Only the access guard runs here. It prints a
     deny and nothing else: grants and search footers are for an agent that
     can act on them. Any failure denies (fail closed).
+
+    ``--worker-state DIR``: a write-mode worker; see ``worker_run``.
     """
     import argparse
     import json
@@ -520,6 +583,7 @@ def main() -> None:
     ensure_utf8_stdio()
     parser = argparse.ArgumentParser()
     parser.add_argument("--project", required=True)
+    parser.add_argument("--worker-state", default="")
     args = parser.parse_args()
     try:
         raw = sys.stdin.read()
@@ -527,9 +591,13 @@ def main() -> None:
         if not isinstance(payload, dict):
             raise ValueError("hook payload must be a JSON object")
         # access_guard canonicalizes the base itself (no direct resolve here).
-        out = run(payload, Path(args.project))
+        if args.worker_state:
+            out = worker_run(payload, Path(args.project), Path(args.worker_state))
+        else:
+            out = run(payload, Path(args.project))
     except Exception as exc:
-        out = _deny(f"[c3-access:error] scout guard failed ({type(exc).__name__}: {exc}); "
+        who = "worker" if args.worker_state else "scout"
+        out = _deny(f"[c3-access:error] {who} guard failed ({type(exc).__name__}: {exc}); "
                     "refusing the call")
     if isinstance(out, dict) and isinstance(out.get("hookSpecificOutput"), dict):
         print(json.dumps({"hookSpecificOutput": out["hookSpecificOutput"]}))

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.138.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.138.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.138.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
@@ -806,11 +826,13 @@ async def c3_delegate(task: str, task_type: str = "ask", context: str = "",
                 file_path: str = "", backend: str = "host",
                 allow_write_delegation: bool = False,
                 tier: str = "", model: str = "", scout: bool = False,
+                write_paths: 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; 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.
+    write_paths: comma-separated project-relative globs the delegate may edit or create (write mode; claude only, tier defaults to medium). You decide the change: say what to change, where, and the intended behaviour. It cannot run commands. You get back the diff (each change is in the edit ledger): review it and run the tests yourself. Access Guard applies; confirm-held, locked, .git/ and .c3/ paths are refused.
     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."""
     svc = _svc(ctx)
@@ -825,10 +847,15 @@ 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,
-                                       allow_write_delegation, tier, model, scout)
+                                       allow_write_delegation, tier, model, scout,
+                                       write_paths)
     finally:
         svc._agent_progress_cb = None
 
@@ -876,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()