code-context-control 2.153.0__py3-none-any.whl → 2.155.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.153.0"
+__version__ = "2.155.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"
@@ -1288,6 +1288,14 @@ def cmd_init(args):
     except Exception:
         pass
 
+    swept = _prune_project_quarantines(project_path)
+    if swept["pruned"]:
+        print(f"  Fixed : freed {_format_bytes(swept['bytes'])} from "
+              f"{len(swept['pruned'])} old embedding quarantine dir(s)")
+    for name in swept["failed"]:
+        print(f"  [warn] {name} could not be fully removed (in use?); "
+              "run 'c3 prune-quarantine' later")
+
     # Delegate backends
     try:
         from services.ollama_client import OllamaClient as _OC
@@ -1463,6 +1471,59 @@ def cmd_index(args):
     return common_cmd_index(args, _command_deps())
 
 
+def _format_bytes(n: float) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1024:
+            return f"{n:.0f} {unit}" if unit == "B" else f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+def _prune_project_quarantines(project_path: str, keep=None, dry_run: bool = False) -> dict:
+    """Prune one project's ``.c3/embeddings/quarantine_corrupt_*`` dirs; returns the sweep result."""
+    from cli.progress import ProgressLine
+    from services.embedding_index import prune_quarantines
+
+    prog = ProgressLine()
+    try:
+        return prune_quarantines(
+            Path(project_path) / CONFIG_DIR / "embeddings", keep=keep, dry_run=dry_run,
+            on_progress=lambda done, total: prog.update(
+                f"  removing quarantine copies {done}/{total}"))
+    finally:
+        prog.done()
+
+
+def cmd_prune_quarantine(args):
+    """Delete old corrupt-embedding-store quarantine copies, keeping the newest few."""
+    if args.all:
+        from services.project_manager import ProjectManager
+        projects = [p["path"] for p in ProjectManager().list_registered()]
+    else:
+        projects = [str(Path(args.project_path or ".").resolve())]
+
+    verb = "would remove" if args.dry_run else "removed"
+    pruned = failed = freed = 0
+    for project in projects:
+        res = _prune_project_quarantines(project, keep=args.keep, dry_run=args.dry_run)
+        if not (res["pruned"] or res["failed"]):
+            continue
+        pruned += len(res["pruned"])
+        failed += len(res["failed"])
+        freed += res["bytes"]
+        print(f"{project}: {verb} {len(res['pruned'])} quarantine dir(s), "
+              f"{_format_bytes(res['bytes'])}; kept {len(res['kept'])}")
+        for name in res["failed"]:
+            print(f"  [warn] {name} could not be fully removed (in use?); run again later")
+
+    if not (pruned or failed):
+        print(f"Nothing to prune in {len(projects)} project(s).")
+        return
+    print(f"\n{verb.capitalize()} {pruned} quarantine dir(s), {_format_bytes(freed)}.")
+    if failed:
+        sys.exit(1)
+
+
 def cmd_compress(args):
     """Compress a file and show results."""
     return common_cmd_compress(args, _command_deps())
@@ -9603,6 +9664,7 @@ def main():
         "enforce": cmd_enforce,
         "override": cmd_override,
         "locks": cmd_locks,
+        "prune-quarantine": cmd_prune_quarantine,
         "ci": cmd_ci,
         "oracle": cmd_oracle,
         "upgrade": cmd_upgrade,

cli/commands/parser.py

@@ -37,6 +37,17 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_upgrade.add_argument("--check", action="store_true",
                            help="Only report whether a newer version exists; don't install")
 
+    p_prune = subparsers.add_parser(
+        "prune-quarantine",
+        help="Delete old corrupt-embedding-store quarantine copies (frees disk)")
+    p_prune.add_argument("project_path", nargs="?", default=".")
+    p_prune.add_argument("--all", action="store_true",
+                         help="Every project registered with the hub, not just this one")
+    p_prune.add_argument("--keep", type=int, default=None,
+                         help="Newest quarantine dirs to keep per project (default 2)")
+    p_prune.add_argument("--dry-run", action="store_true",
+                         help="Report what would be removed without deleting")
+
     p_index = subparsers.add_parser("index", help="Rebuild code index")
     p_index.add_argument("--max-files", type=int, default=None,
                          help="Cap files indexed this run. Unset reads "

cli/guide/index.html

@@ -663,6 +663,10 @@
             <code>c3 map {status|ensure|refresh}</code>
             <span>Inspect or rebuild the live repo map at .c3/MAP.md</span>
           </div>
+          <div class="quick-item">
+            <code>c3 prune-quarantine [--all] [--dry-run]</code>
+            <span>Free disk held by old corrupt-embedding-store copies in .c3/embeddings (<code>c3 init</code> runs it too)</span>
+          </div>
           <div class="quick-item">
             <code>c3 hub</code>
             <span>Launch the Project Hub web dashboard (localhost:3330)</span>

cli/hook_session_open.py

@@ -30,6 +30,12 @@ the hub, and it skips a project that already has a live UI port, so a
 ``C3_NO_UI_AUTOSTART=1`` or
 ``.c3/config.json → {"ui": {"autostart_on_session": false}}``.
 
+A ``clear`` (or an in-session ``resume``) keeps the MCP server it already
+has, under a host session id that just ended. This hook finds that server
+by the host pid both of them share and hands it the new id
+(``services.host_handoff``, v2.155.0); the server then writes the
+``C3 connected <new id>`` row the desktop sentinel is waiting for.
+
 ``source: "compact"`` writes NOTHING: a compaction is the same session and
 the same MCP process, and a "Session started" toast on every compaction
 would teach the user to ignore the real ones.
@@ -48,6 +54,8 @@ from __future__ import annotations
 import json
 import os
 import sys
+import time
+import uuid
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
@@ -56,6 +64,11 @@ from cli._hook_utils import detect_host, find_project, log_hook_error  # noqa: E
 from cli.hook_session_end import short_id  # noqa: E402
 
 _SILENT_SOURCES = {"compact"}
+# How long one session's UI launch holds the project against the next. A
+# server lands in the registry only after it binds its port, a few seconds
+# after Popen; this covers that gap with room to spare. After it, the live
+# registry entry (``_ui_running``) is the guard again.
+_LAUNCH_GRACE_S = 90.0
 
 
 def _ui_autostart_enabled(project: Path) -> bool:
@@ -96,7 +109,10 @@ def _ui_running(pm, project: Path) -> bool:
     """True when a live UI server is already registered for this project.
 
     This is what keeps `resume` / `clear` — both real SessionStart events —
-    from stacking a second server on every reconnect.
+    from stacking a second server on every reconnect. A registered server
+    whose port is quiet but whose pid is running is still "running": it is
+    starting up, or busy, and a second one would only be the leak this
+    check exists to prevent (2.155.0).
     """
     target = os.path.normcase(str(project))
     for entry in pm._read_registry():
@@ -107,8 +123,72 @@ def _ui_running(pm, project: Path) -> bool:
             same = os.path.normcase(str(Path(raw).resolve())) == target
         except Exception:
             same = os.path.normcase(raw) == target
-        if same and entry.get("port") and pm._port_alive(entry["port"]):
+        if not same or not entry.get("port"):
+            continue
+        if pm._port_alive(entry["port"]):
+            return True
+        if entry.get("pid") and pm._pid_alive(entry.get("pid")):
+            return True
+    return False
+
+
+def _launch_lock(project: Path) -> Path:
+    return project / ".c3" / "ui_launch.lock"
+
+
+def _claim_launch(project: Path) -> bool:
+    """Atomically claim the right to launch this project's UI server.
+
+    ``_ui_running`` only sees a server once it has registered its port, a
+    few seconds after launch. Sessions that open inside that window (an
+    agent spawning several at once, or a resume racing a startup) each saw
+    no live UI and each launched one, which is how a project ended up with
+    two servers. The first claimant creates ``.c3/ui_launch.lock`` with
+    O_EXCL; anyone else inside ``_LAUNCH_GRACE_S`` stands down.
+
+    A lock older than the grace window is stale (the launch died, or the
+    server since exited). It is taken over by renaming it to a unique name,
+    which only one contender can do, then the create is retried. If the
+    lock cannot be handled at all the answer is True, which is the
+    behaviour from before this lock existed: a missing UI is worse than a
+    rare duplicate.
+    """
+    lock = _launch_lock(project)
+    try:
+        lock.parent.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        return True
+    for _ in range(3):
+        try:
+            fd = os.open(str(lock), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+        except FileExistsError:
+            try:
+                age = time.time() - lock.stat().st_mtime
+            except FileNotFoundError:
+                continue  # released between our create and stat; retry
+            except Exception:
+                return True
+            if age < _LAUNCH_GRACE_S:
+                return False
+            stale = lock.with_name(f"ui_launch.stale-{uuid.uuid4().hex}")
+            try:
+                os.rename(str(lock), str(stale))
+            except FileNotFoundError:
+                continue  # another contender took it over first
+            except Exception:
+                return False
+            try:
+                stale.unlink()
+            except Exception:
+                pass
+            continue
+        except Exception:
             return True
+        try:
+            os.write(fd, f"{os.getpid()} {time.time():.0f}\n".encode("ascii"))
+        finally:
+            os.close(fd)
+        return True
     return False
 
 
@@ -136,6 +216,8 @@ def ensure_ui(project: Path, host_session_id: str = "") -> str:
             return "unregistered"
         if _ui_running(pm, project):
             return "already-running"
+        if not _claim_launch(project):
+            return "launch-pending"
         # launch_session copies os.environ into the detached child, which is
         # where cli/server._register_session reads the ownership from.
         os.environ["C3_UI_OWNER"] = "session"
@@ -150,6 +232,22 @@ def ensure_ui(project: Path, host_session_id: str = "") -> str:
         return "error"
 
 
+def hand_off_runtime(project: Path, host: str, host_sid: str, start_source: str) -> list:
+    """Point the MCP server this host already runs at its new session id.
+
+    Returns the C3 session ids handed off (usually one, often none: a
+    ``startup`` has no server yet). Never raises.
+    """
+    if not host_sid:
+        return []
+    try:
+        from services.host_handoff import hand_off
+        return hand_off(project, host, host_sid, start_source)
+    except Exception as exc:
+        log_hook_error("hook_session_open", exc)
+        return []
+
+
 def run(payload: dict, project_path: Path | None = None):
     """Core logic — importable by the dispatcher and tests. Returns None."""
     start_source = str(payload.get("source") or "").strip().lower()
@@ -178,6 +276,7 @@ def run(payload: dict, project_path: Path | None = None):
                kind="session", ref_id=host_sid)
     except Exception:
         pass
+    hand_off_runtime(project, host, host_sid, start_source)
     ensure_ui(project, host_sid)
     return None
 

cli/mcp_server.py

@@ -165,6 +165,93 @@ def _link_host_session(svc, host_sid: str) -> None:
         pass
 
 
+# ── Host handoff (2.155.0): follow a /clear to its new host session id ─────
+# The pid of the IDE / agent CLI above this process (services.host_handoff).
+# Written into every heartbeat; the SessionStart hook matches on it.
+_HOST_PID = 0
+# How often the heartbeat thread looks for a handoff file. The desktop
+# sentinel gives a new session 30 s to produce a `C3 connected` row.
+_HANDOFF_POLL_S = 5
+
+
+def _rebind_host_session(svc, host_sid: str, start_source: str = "") -> bool:
+    """Adopt ``host_sid`` as this server's host session id. Returns True when
+    something changed.
+
+    Everything that was derived from the old id is redone: the session
+    record (what ``_grants.session_id`` and the access guard read), the
+    host env var (what a c3_project proxy runtime built later would read),
+    the host↔C3 link file, the heartbeat — and the ``C3 connected <id>``
+    notification, which is what C3 Desk's "did not connect" sentinel waits
+    for after the hook's ``Session started <id>``.
+    """
+    host_sid = str(host_sid or "").strip()
+    session = getattr(getattr(svc, "session_mgr", None), "current_session", None)
+    if not host_sid or not isinstance(session, dict):
+        return False
+    previous = str(session.get("host_session_id") or "")
+    if previous == host_sid:
+        return False
+    session["host_session_id"] = host_sid
+    ide = getattr(svc, "ide_name", "") or _IDE_NAME
+    try:
+        from core.host import session_env_var
+        var = session_env_var(ide)
+        if var:
+            os.environ[var] = host_sid
+    except Exception:
+        pass
+    try:
+        import dataclasses
+        base = getattr(svc, "host_context", None) or _HOST
+        ctx = dataclasses.replace(base, host_session_id=host_sid)
+        svc.host_context = ctx
+        if getattr(svc, "session_mgr", None) is not None:
+            svc.session_mgr.host_context = ctx
+    except Exception:
+        pass
+    with _host_sid_lock:
+        _host_sid_cache["value"] = host_sid
+        _host_sid_cache["read_at"] = time.monotonic()
+        _host_sid_cache["linked"] = ""
+    _link_host_session(svc, host_sid)
+    try:
+        svc.activity_log.log("session_rebind", {
+            "session_id": str(session.get("id") or ""),
+            "host_session_id": host_sid,
+            "previous_host_session_id": previous,
+            "start_source": str(start_source or ""),
+        })
+    except Exception:
+        pass
+    try:
+        from services import session_live
+        session_live.beat(svc.project_path, str(session.get("id") or ""),
+                          host_session_id=host_sid, ide=ide, host_pid=_HOST_PID)
+    except Exception:
+        pass
+    _notify_mcp_ready(svc)
+    return True
+
+
+def _check_handoff(svc) -> bool:
+    """Consume a pending handoff file for this session, if any. Never raises."""
+    try:
+        session = getattr(getattr(svc, "session_mgr", None), "current_session", None) or {}
+        c3_id = str(session.get("id") or "")
+        if not c3_id:
+            return False
+        from services import host_handoff
+        data = host_handoff.read_handoff(svc.project_path, c3_id)
+        if not data:
+            return False
+        host_handoff.clear_handoff(svc.project_path, c3_id)
+        return _rebind_host_session(svc, str(data.get("host_session_id") or ""),
+                                    str(data.get("start_source") or ""))
+    except Exception:
+        return False
+
+
 def _notify_mcp_ready(svc) -> None:
     """``kind="mcp"`` / ``C3 connected`` — the runtime is ready to serve (D0b).
 
@@ -341,19 +428,36 @@ async def lifespan(server):
     if _live_session_id:
         from services import session_live
 
+        global _HOST_PID
+        try:
+            from services.host_handoff import host_process_id
+            _HOST_PID = int(host_process_id() or 0)
+        except Exception:
+            _HOST_PID = 0
+
         def _do_beat():
             session_live.beat(services.project_path, _live_session_id,
                               host_session_id=_host_session_id(services) or "",
-                              ide=_IDE_NAME)
+                              ide=_IDE_NAME, host_pid=_HOST_PID)
 
         _do_beat()
 
         def _bg_heartbeat():
-            while not _heartbeat_stop.wait(timeout=session_live.HEARTBEAT_INTERVAL_S):
+            # Wakes every _HANDOFF_POLL_S to look for a handoff (a /clear
+            # moved this server to a new host session id), and beats every
+            # HEARTBEAT_INTERVAL_S as before.
+            last_beat = time.monotonic()
+            while not _heartbeat_stop.wait(timeout=_HANDOFF_POLL_S):
                 try:
-                    _do_beat()
+                    _check_handoff(services)
                 except Exception:
                     pass
+                if time.monotonic() - last_beat >= session_live.HEARTBEAT_INTERVAL_S:
+                    last_beat = time.monotonic()
+                    try:
+                        _do_beat()
+                    except Exception:
+                        pass
 
         threading.Thread(target=_bg_heartbeat, daemon=True,
                          name="c3-session-heartbeat").start()
@@ -423,6 +527,9 @@ async def lifespan(server):
     # notification within 30 s, so this must be the LAST thing before the
     # handshake proceeds and must never be skipped on a partial init.
     _notify_mcp_ready(services)
+    # A /clear that landed while this process was still starting left its
+    # handoff waiting; take it now rather than at the first poll.
+    _check_handoff(services)
 
     try:
         yield services
@@ -517,6 +624,10 @@ def _ensure_repo_map_once(rt) -> None:
 def _svc(ctx: Context) -> C3Runtime:
     rt = ctx.request_context.lifespan_context
     _ensure_repo_map_once(rt)
+    # A tool call right after a /clear must already run under the new host
+    # id (grants and leases are keyed by it): one stat per call, before the
+    # access guard binds the session.
+    _check_handoff(rt)
     access_guard.bind_session(_grants.session_id(rt))
     return rt
 

cli/server.py

@@ -63,19 +63,8 @@ _HUB_CONFIG_FILE = _GLOBAL_C3_DIR / "hub_config.json"
 
 
 def _registry_read() -> list:
-    try:
-        if _REGISTRY_FILE.exists():
-            with open(_REGISTRY_FILE, encoding="utf-8") as f:
-                return json.load(f)
-    except Exception:
-        pass
-    return []
-
-
-def _registry_write(entries: list):
-    _GLOBAL_C3_DIR.mkdir(parents=True, exist_ok=True)
-    with open(_REGISTRY_FILE, "w", encoding="utf-8") as f:
-        json.dump(entries, f, indent=2)
+    from services import ui_registry
+    return ui_registry.read(_REGISTRY_FILE)
 
 
 def _read_hub_config() -> dict:
@@ -103,32 +92,54 @@ def _port_alive(port: int) -> bool:
         return False
 
 
-def _register_session(port: int, project_path: str, project_name: str):
+# Seconds between a running server's re-assertions of its own registry entry
+# (services.ui_registry.ensure). A lost entry — an older hub rewriting the
+# file from a stale snapshot, a crash mid-write — comes back within one tick
+# instead of leaving a server nothing can find, reap or reuse.
+_REGISTRY_REASSERT_S = 60
+
+
+def _registry_entry(port: int, project_path: str, project_name: str) -> dict:
+    # owner says who asked for this server: "session" when an IDE session
+    # start launched it (cli/hook_session_open), "user" for `c3 ui`, the
+    # hub's Open UI button and the TUI. Only session-owned servers are
+    # ever reaped automatically (ProjectManager.sweep_registry).
+    return {
+        "port": port,
+        "project_path": project_path,
+        "project_name": project_name,
+        "started_at": time.time(),
+        "pid": os.getpid(),
+        "owner": (os.environ.get("C3_UI_OWNER") or "user").strip().lower(),
+        "owner_session": (os.environ.get("C3_UI_OWNER_SESSION") or "").strip(),
+    }
+
+
+def _register_session(port: int, project_path: str, project_name: str) -> dict:
+    """Upsert this server's entry under the registry lock (2.155.0).
+
+    This used to drop every OTHER entry whose port missed a 0.3 s connect —
+    a sibling server busy re-indexing was deregistered by the next one to
+    start, and lived on as an orphan. Pruning is the hub sweep's job now,
+    and it only drops an entry whose pid is gone as well.
+    """
+    from services import ui_registry
+    entry = _registry_entry(port, project_path, project_name)
     with _REGISTRY_LOCK:
-        entries = _registry_read()
-        # Remove our own port and any stale (dead) entries
-        entries = [e for e in entries if e.get("port") != port and _port_alive(e.get("port", 0))]
-        # owner says who asked for this server: "session" when an IDE session
-        # start launched it (cli/hook_session_open), "user" for `c3 ui`, the
-        # hub's Open UI button and the TUI. Only session-owned servers are
-        # ever reaped automatically (ProjectManager.sweep_registry).
-        entries.append({
-            "port": port,
-            "project_path": project_path,
-            "project_name": project_name,
-            "started_at": time.time(),
-            "pid": os.getpid(),
-            "owner": (os.environ.get("C3_UI_OWNER") or "user").strip().lower(),
-            "owner_session": (os.environ.get("C3_UI_OWNER_SESSION") or "").strip(),
-        })
-        _registry_write(entries)
+        ui_registry.upsert(entry, _REGISTRY_FILE)
+    return entry
+
+
+def _reassert_registration(entry: dict) -> bool:
+    from services import ui_registry
+    with _REGISTRY_LOCK:
+        return ui_registry.ensure(entry, _REGISTRY_FILE)
 
 
 def _unregister_session(port: int):
+    from services import ui_registry
     with _REGISTRY_LOCK:
-        entries = _registry_read()
-        entries = [e for e in entries if e.get("port") != port]
-        _registry_write(entries)
+        ui_registry.remove_ports([port], _REGISTRY_FILE)
 
 
 def init_services(project_path: str):
@@ -4536,8 +4547,19 @@ def run_server(
         # Fallback chain: custom meta name → folder name → parent/folder for disambiguation
         _folder = _resolved.name or _resolved.parent.name or "project"
         _proj_name = (_meta.get("name") or "").strip() or _folder
-        _register_session(port, str(_resolved), _proj_name)
+        _entry = _register_session(port, str(_resolved), _proj_name)
         atexit.register(_unregister_session, port)
+
+        def _bg_reassert():
+            while True:
+                time.sleep(_REGISTRY_REASSERT_S)
+                try:
+                    _reassert_registration(_entry)
+                except Exception:
+                    pass
+
+        threading.Thread(target=_bg_reassert, daemon=True,
+                         name="c3-ui-registry-reassert").start()
     except Exception:
         pass
 

cli/tools/_grants.py

@@ -51,6 +51,24 @@ def session_id(svc) -> str:
     return str(session.get("id", "") or "") or f"pid-{os.getpid()}"
 
 
+def agent_id(svc) -> str:
+    """One caller label for explicit locks and implicit edit leases.
+
+    Runtime host identity belongs to the caller, including c3_project proxies;
+    the target project's preferred editor must not override it.
+    """
+    from core.host import resolve_host
+    from services.agent_locks import agent_id_for
+
+    provider = getattr(svc, "ide_name", "")
+    if not isinstance(provider, str) or not provider.strip():
+        session = getattr(getattr(svc, "session_mgr", None), "current_session", None) or {}
+        provider = session.get("source_ide", "")
+    if not isinstance(provider, str) or not provider.strip():
+        provider = resolve_host(str(getattr(svc, "project_path", "") or "")).provider
+    return agent_id_for(session_id(svc), provider=provider)
+
+
 def allow(svc, denial, *, tool: str, op: str, path,
           peek: bool = False) -> str | None:
     """The `[c3-override:granted]` line when a live grant permits this exact

cli/tools/edit.py

@@ -566,7 +566,8 @@ def _write_gate(svc, path: Path, rel: str, file_path: str, op: str,
                                "holder": holder.get("agent_id", ""),
                                "held_for_s": held_for},
                         agent_locks.refusal(holder, rel), "lock held")
-    agent_locks.lease(str(path), svc.project_path, session_id, intent=intent)
+    agent_locks.lease(str(path), svc.project_path, session_id, intent=intent,
+                      agent_id=_grants.agent_id(svc))
     return None
 
 

cli/tools/locks.py

@@ -40,7 +40,7 @@ def handle_locks(action: str, paths: str, intent: str, ttl_s: int,
     """Route c3_locks actions."""
     project = str(svc.project_path)
     session = _session_id(svc)
-    agent = al.agent_id_for(session)
+    agent = _grants.agent_id(svc)
     args = {"action": action}
 
     cfg = al.config(project)

cli/tools/project.py

@@ -54,6 +54,19 @@ def _runtime_for(path: str):
     return shared_cache().get(path)
 
 
+class _CallerLabelRuntime:
+    """Use the caller's provider label without changing target session ownership."""
+
+    def __init__(self, target, caller):
+        from cli.tools import _grants
+
+        self._target = target
+        self.ide_name = _grants.agent_id(caller).split(":", 1)[0]
+
+    def __getattr__(self, name):
+        return getattr(self._target, name)
+
+
 def _is_registered(path: str) -> bool:
     """True when *path* is in the cross-project registry. Fails closed."""
     try:
@@ -524,6 +537,11 @@ def handle_project(action, svc, finalize, *, project="", query="", file_path="",
         return done(
             f"[c3_project:error] Could not load '{resolved['name']}': {e}", "error")
 
+    # Label edit leases with the requesting host, without mutating the cached
+    # runtime or borrowing the caller's session/grant identity in the target.
+    if action == "edit":
+        fsvc = _CallerLabelRuntime(fsvc, svc)
+
     banner = f"[c3_project:{resolved['name']}] {action}\n"
     try:
         body = _proxy(

{code_context_control-2.153.0.dist-info → code_context_control-2.155.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.153.0
+Version: 2.155.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