code-context-control 2.154.0__tar.gz → 2.155.0__tar.gz

{code_context_control-2.154.0 → code_context_control-2.155.0}/PKG-INFO

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

{code_context_control-2.154.0 → code_context_control-2.155.0}/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.154.0"
+__version__ = "2.155.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"

{code_context_control-2.154.0 → code_context_control-2.155.0}/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
 

{code_context_control-2.154.0 → code_context_control-2.155.0}/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
 

{code_context_control-2.154.0 → code_context_control-2.155.0}/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
 

{code_context_control-2.154.0 → code_context_control-2.155.0}/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

{code_context_control-2.154.0 → code_context_control-2.155.0}/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
 
 

{code_context_control-2.154.0 → code_context_control-2.155.0}/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)

{code_context_control-2.154.0 → code_context_control-2.155.0}/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.154.0 → code_context_control-2.155.0}/code_context_control.egg-info/PKG-INFO

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

{code_context_control-2.154.0 → code_context_control-2.155.0}/code_context_control.egg-info/SOURCES.txt

@@ -252,6 +252,7 @@ services/file_memory.py
 services/git_context.py
 services/grok_integration.py
 services/grok_transcript.py
+services/host_handoff.py
 services/host_sessions.py
 services/hub_service.py
 services/index_store.py
@@ -314,6 +315,7 @@ services/text_index.py
 services/time_tracker.py
 services/tool_classifier.py
 services/transcript_index.py
+services/ui_registry.py
 services/validation_cache.py
 services/vector_store.py
 services/watcher.py
@@ -430,6 +432,8 @@ tests/test_hook_session_end.py
 tests/test_hook_smoke.py
 tests/test_hook_state.py
 tests/test_hook_utf8_stdio.py
+tests/test_host_handoff.py
+tests/test_host_rebind.py
 tests/test_hub_access_routes.py
 tests/test_hub_builtin_routes.py
 tests/test_hub_credentials_route.py
@@ -509,6 +513,7 @@ tests/test_override_requests.py
 tests/test_override_wake.py
 tests/test_permissions.py
 tests/test_pm_api.py
+tests/test_project_lease_identity.py
 tests/test_project_manager.py
 tests/test_project_manager_merge.py
 tests/test_project_tool.py
@@ -560,6 +565,7 @@ tests/test_token_telemetry.py
 tests/test_token_tracking.py
 tests/test_tool_registry.py
 tests/test_ui_jsx_syntax.py
+tests/test_ui_registry.py
 tests/test_upgrade_and_version.py
 tests/test_validate.py
 tests/test_vault_write_guard.py

{code_context_control-2.154.0 → code_context_control-2.155.0}/core/host.py

@@ -8,6 +8,18 @@ from dataclasses import dataclass
 
 from core.ide import get_profile, load_ide_config, normalize_ide_name
 
+# The environment variable each host puts its session id in. The MCP server
+# reads it once at start; after a /clear it is REWRITTEN in-process by
+# cli/mcp_server._rebind_host_session so that runtimes built later in the same
+# process (the c3_project proxy) inherit the new id — see services.host_handoff.
+SESSION_ENV = {"claude-code": "CLAUDE_CODE_SESSION_ID", "codex": "CODEX_THREAD_ID",
+               "grok": "GROK_SESSION_ID"}
+
+
+def session_env_var(provider: str | None) -> str:
+    """The env var carrying ``provider``'s session id, or ``""``."""
+    return SESSION_ENV.get(normalize_ide_name(provider or ""), "")
+
 
 @dataclass(frozen=True)
 class HostContext:
@@ -35,7 +47,5 @@ def resolve_host(project_path: str = "", explicit_host: str | None = None,
     # Grok is never inferred from GROK_SESSION_ID: a grok launched from a Claude
     # Code terminal also inherits CLAUDE_CODE_SESSION_ID, so its MCP entry and
     # hooks name the host explicitly (--host grok) instead.
-    session_env = {"claude-code": "CLAUDE_CODE_SESSION_ID", "codex": "CODEX_THREAD_ID",
-                   "grok": "GROK_SESSION_ID"}
-    session = str(env.get(session_env.get(provider, ""), "") or "").strip()
+    session = str(env.get(SESSION_ENV.get(provider, ""), "") or "").strip()
     return HostContext(provider, session)

{code_context_control-2.154.0 → code_context_control-2.155.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.154.0"
+version = "2.155.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.154.0 → code_context_control-2.155.0}/services/agent_locks.py

@@ -170,10 +170,12 @@ def normalize_relpath(filepath, root) -> str:
     return rel
 
 
-def agent_id_for(session_id: str) -> str:
-    """FleetDeck's convention (fleetdeck/hook.py) so both name one agent alike."""
+def agent_id_for(session_id: str, provider: str = "claude-code") -> str:
+    """Label the actual provider; preserve legacy Claude hook callers."""
+    from core.ide import normalize_ide_name
+    provider = normalize_ide_name(provider)
     sid = (session_id or "").strip()
-    return f"claude-code:{sid[:8]}" if sid else "claude-code"
+    return f"{provider}:{sid[:8]}" if sid else provider
 
 
 # ── Engine ──────────────────────────────────────────────────────────────────
@@ -496,7 +498,8 @@ def check(path, project_path=".", session_id: str = ""):
         return None
 
 
-def lease(path, project_path=".", session_id: str = "", intent: str = "") -> bool:
+def lease(path, project_path=".", session_id: str = "", intent: str = "",
+          agent_id: str = "") -> bool:
     """Best-effort implicit lease on one file, for c3_edit to call.
 
     Implicit rather than explicit by design (spec §14): an explicit
@@ -512,7 +515,7 @@ def lease(path, project_path=".", session_id: str = "", intent: str = "") -> boo
             return False
         text = (intent or "").strip()[:120] or "editing via c3_edit"
         res = store_for(project_path).acquire(
-            [path], agent_id=agent_id_for(session_id),
+            [path], agent_id=agent_id or agent_id_for(session_id),
             session_id=session_id, intent=text)
         return bool(res.get("granted"))
     except Exception: