code-context-control 2.126.1__tar.gz → 2.128.1__tar.gz

{code_context_control-2.126.1 → code_context_control-2.128.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.126.1
+Version: 2.128.1
 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
@@ -168,6 +168,8 @@ c3 ui                             # binds the first free port from 3333
 
 Twelve tabs. The dashboard above shows token savings, indexed files, the live session, and a stream of recent tool calls and file changes.
 
+Since v2.128.0 you rarely start it by hand: opening an IDE session in a registered project brings its UI up, and a session proves it is alive with a heartbeat rather than with tool-call traffic — so a quiet session stays live and a closed one disappears at once. Servers a session started are reaped once the session is gone; the ones you started are not. → [Session liveness](https://github.com/drknowhow/code-context-control/blob/main/docs/session-liveness.md)
+
 | Tab | What it's for |
 |---|---|
 | **Dashboard** | Token savings, codebase breakdown, live session counters, recent activity |

{code_context_control-2.126.1 → code_context_control-2.128.1}/README.md

@@ -102,6 +102,8 @@ c3 ui                             # binds the first free port from 3333
 
 Twelve tabs. The dashboard above shows token savings, indexed files, the live session, and a stream of recent tool calls and file changes.
 
+Since v2.128.0 you rarely start it by hand: opening an IDE session in a registered project brings its UI up, and a session proves it is alive with a heartbeat rather than with tool-call traffic — so a quiet session stays live and a closed one disappears at once. Servers a session started are reaped once the session is gone; the ones you started are not. → [Session liveness](https://github.com/drknowhow/code-context-control/blob/main/docs/session-liveness.md)
+
 | Tab | What it's for |
 |---|---|
 | **Dashboard** | Token savings, codebase breakdown, live session counters, recent activity |

{code_context_control-2.126.1 → code_context_control-2.128.1}/cli/_hook_utils.py

@@ -8,6 +8,7 @@ All hook reads/writes of enforcement state MUST go through this module.
 import json
 import os
 import re
+import shlex
 import sys
 import traceback
 from datetime import datetime, timezone
@@ -34,6 +35,27 @@ LEGACY_UNLOCK_FILE = ".c3/unlocked_files.json"
 STATE_WARNINGS: list = []
 
 
+def hook_command_arg(raw) -> str:
+    """Quote one argv element for a hook ``command`` string in settings.
+
+    Windows: a DOUBLE-quoted forward-slash path. Claude Code runs hooks through
+    Git Bash, where ``shlex.quote`` produces SINGLE quotes around a backslash
+    path — cmd.exe does not treat single quotes as quoting, so any path with a
+    space or parentheses (``Claude Code Companion (C3)``) breaks. A
+    double-quoted forward-slash path is parsed correctly by bash AND cmd.
+    Verified 2026-07-26 under Git Bash on Windows 11; the installer in
+    cli/c3.py carries the full investigation, including why no ``cmd.exe /c``
+    wrapper belongs here.
+
+    Anything that writes a hook command — the installer and the hub's
+    migration — must go through this, or the entry it writes is dead on
+    Windows.
+    """
+    if sys.platform == "win32":
+        return '"' + str(raw).replace("\\", "/") + '"'
+    return shlex.quote(str(raw))
+
+
 def ensure_utf8_stdio() -> None:
     """Force UTF-8 on the hook process's stdio pipes.
 

{code_context_control-2.126.1 → code_context_control-2.128.1}/cli/c3.py

@@ -33,7 +33,6 @@ import json
 import logging
 import os
 import re
-import shlex
 import subprocess
 import sys
 import tempfile
@@ -92,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.126.1"
+__version__ = "2.128.1"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -5542,10 +5541,10 @@ def cmd_install_mcp(args):
         # the wrapper was never needed. A double-quoted forward-slash path is parsed
         # correctly by bash AND cmd, including paths containing spaces or parentheses
         # (e.g. "Claude Code Companion (C3)"), which is why the wrapper was added.
-        def _hook_arg(raw: str) -> str:
-            if sys.platform == "win32":
-                return '"' + str(raw).replace("\\", "/") + '"'
-            return shlex.quote(str(raw))
+        # Lives in cli/_hook_utils so the hub's hook migration quotes commands
+        # the same way — it used shlex.quote and wrote entries that Windows
+        # could not run.
+        from cli._hook_utils import hook_command_arg as _hook_arg
 
         # v2.42: single dispatcher script per hook event instead of N separate
         # per-hook commands. One interpreter spawn per event; the dispatcher
@@ -6968,8 +6967,10 @@ def cmd_override(args):
     """
     sub = getattr(args, "override_cmd", None)
     if not sub:
-        print("Usage: c3 override <policy|grant|list|revoke|check|sweep> ...")
+        print("Usage: c3 override <policy|grant|list|revoke|check|sweep|"
+              "requests|approve|deny|costs> ...")
         print("       c3 override policy    # what is escalatable right now")
+        print("       c3 override costs     # which rules keep holding the agent")
         return
 
     from services import override_grants as og
@@ -6998,6 +6999,39 @@ def cmd_override(args):
         _override_requests(args, project_path)
     elif sub in ("approve", "deny"):
         _override_decide(args, sub, project_path)
+    elif sub == "costs":
+        _override_costs(args, project_path)
+
+
+def _override_costs(args, project_path: str) -> None:
+    """`c3 override costs` — which rules keep holding the agent (§11 T5)."""
+    from services import override_costs as ocost
+
+    days = max(1, int(getattr(args, "days", None) or ocost.DEFAULT_DAYS))
+    everywhere = bool(getattr(args, "all_projects", False))
+    rows = ocost.rule_costs(project_path=None if everywhere else project_path,
+                            days=days)
+    print_header(f"Override costs — last {days} day(s)"
+                 + ("" if everywhere else f" · {Path(project_path).name}"))
+    if not rows:
+        print("  (no requests in the window)")
+        return
+    width = max(len(r["rule"]) for r in rows)
+    print(f"  {'held':>4} {'ok':>3} {'no':>3} {'exp':>3} {'wait':>4}  "
+          f"{'rule':<{width}}  suggestion")
+    for r in rows:
+        line = (f"  {r['count']:>4} {r['approved']:>3} {r['denied']:>3} "
+                f"{r['expired']:>3} {r['pending']:>4}  {r['rule']:<{width}}  "
+                f"{r['suggestion']}")
+        if r["count"] >= ocost.NUDGE_THRESHOLD:
+            line += "  <- costing you"
+        print(line)
+        if everywhere:
+            print(f"  {'':22s} {r['project_path']}")
+    print("\n  held = requests filed; ok/no/exp/wait = approved/denied/"
+          "expired/still pending (withdrawn counts in held only).")
+    print("  A rule you keep approving is friction: edit it with `c3 access`. "
+          "A rule you keep denying is working — mute the session instead.")
 
 
 def _override_requests(args, project_path: str) -> None:

{code_context_control-2.126.1 → code_context_control-2.128.1}/cli/commands/parser.py

@@ -779,6 +779,18 @@ def build_parser(version: str, parse_cli_ide_arg):
     ov_deny.add_argument("--path", dest="project_path", default=".",
                          help="Project directory (default: current)")
 
+    # Costs: which rules keep asking (spec §11 Threat 5, v2.127.0). A read
+    # over the request store — it decides nothing and edits no rule.
+    ov_costs = override_subs.add_parser(
+        "costs", help="Which rules held the agent most, and how you answered"
+    )
+    ov_costs.add_argument("--days", type=int, default=7,
+                          help="Trailing window in days (default 7)")
+    ov_costs.add_argument("--all", dest="all_projects", action="store_true",
+                          help="Every project, not just this one")
+    ov_costs.add_argument("--path", dest="project_path", default=".",
+                          help="Project directory (default: current)")
+
     # ── Tool discipline / enforcement mode (v2.66.0) ────────────────────
     # LAYER C: how hard C3 pushes the agent toward c3_* tools. Distinct from
     # `c3 access` (path policy — a security boundary) and from

code_context_control-2.128.1/cli/hook_session_open.py

@@ -0,0 +1,199 @@
+"""SessionStart hook: record that a host session opened (D0b, v2.126.0).
+
+Claude Code's ``SessionStart`` event delivers on stdin::
+
+    {
+      "session_id": "<Claude Code UUID>",
+      "transcript_path": "...",
+      "cwd": "...",
+      "hook_event_name": "SessionStart",
+      "source": "startup" | "resume" | "clear" | "compact"
+    }
+
+Codex's ``SessionStart`` carries its thread id in the same ``session_id``
+field and no ``source``; the dispatcher routes both here (event ``start``).
+
+Records:
+
+- ``{type: "session_open", host_session_id, source: <host>, start_source}``
+  in ``.c3/activity_log.jsonl``. ``source`` is the HOST (``claude`` /
+  ``codex`` / ``gemini``), matching ``session_end``; the payload's own
+  ``source`` (startup / resume / clear) is kept as ``start_source``.
+- a ``session`` notification (``kind="session"``, ``ref_id=host id``,
+  ``info``, title ``Session started <short id>``).
+
+It also brings up the project's UI server when one is not already running
+(``ensure_ui`` below, v2.128.0) — the only place in C3 where "a session
+started" causes "the UI is up". It needs the project to be registered with
+the hub, and it skips a project that already has a live UI port, so a
+``resume`` or ``clear`` never stacks a second server. Opt out with
+``C3_NO_UI_AUTOSTART=1`` or
+``.c3/config.json → {"ui": {"autostart_on_session": false}}``.
+
+``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.
+
+The MCP server's own ``session_start`` row is untouched — it carries the C3
+id and, when the host put its id in the environment, ``host_session_id``
+too. This hook is what lets a client see the session before the runtime has
+finished starting (~seconds), and it is the row the desktop's "MCP failed to
+connect" sentinel starts its 30 s clock from.
+
+Returns None always: SessionStart hook stdout becomes model context, and
+this hook has nothing to tell the model.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cli._hook_utils import detect_host, find_project, log_hook_error  # noqa: E402
+from cli.hook_session_end import short_id  # noqa: E402
+
+_SILENT_SOURCES = {"compact"}
+
+
+def _ui_autostart_enabled(project: Path) -> bool:
+    """Opt-outs, in the order a user reaches for them."""
+    if os.environ.get("C3_NO_UI_AUTOSTART") or os.environ.get("C3_BENCHMARK_MODE"):
+        return False
+    try:
+        cfg = json.loads((project / ".c3" / "config.json").read_text(encoding="utf-8"))
+    except Exception:
+        return True  # no readable config is not a reason to withhold the UI
+    ui = cfg.get("ui")
+    if isinstance(ui, dict) and "autostart_on_session" in ui:
+        return bool(ui.get("autostart_on_session"))
+    return True
+
+
+def _is_registered(pm, project: Path) -> bool:
+    """True when the hub knows this project.
+
+    The UI server is a hub-level surface: a directory the user never
+    registered gets nothing automatic (``c3 ui`` still works). This is also
+    what keeps a test fixture or a scratch clone from growing a web server.
+    """
+    target = os.path.normcase(str(project))
+    for entry in pm._read_projects():
+        raw = str(entry.get("path") or "")
+        if raw and os.path.normcase(raw) == target:
+            return True
+        try:
+            if raw and os.path.normcase(str(Path(raw).resolve())) == target:
+                return True
+        except Exception:
+            continue
+    return False
+
+
+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.
+    """
+    target = os.path.normcase(str(project))
+    for entry in pm._read_registry():
+        raw = str(entry.get("project_path") or "")
+        if not raw:
+            continue
+        try:
+            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"]):
+            return True
+    return False
+
+
+def ensure_ui(project: Path, host_session_id: str = "") -> str:
+    """Bring up this project's UI server for the session that just opened.
+
+    Nothing else in C3 connected "a session started" to "the UI is running":
+    the hub's sweep only chases projects flagged `autostart_ui`, and before
+    2.128.0 it ran once at hub startup — so a UI was only ever there because
+    an earlier session had left one behind.
+
+    Returns a short reason string (tests and diagnostics read it). Never
+    raises and never prints — SessionStart stdout becomes model context.
+    """
+    try:
+        project = Path(project).resolve()
+    except Exception:
+        project = Path(project)
+    if not _ui_autostart_enabled(project):
+        return "disabled"
+    try:
+        from services.project_manager import ProjectManager
+        pm = ProjectManager()
+        if not _is_registered(pm, project):
+            return "unregistered"
+        if _ui_running(pm, project):
+            return "already-running"
+        # 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"
+        if host_session_id:
+            os.environ["C3_UI_OWNER_SESSION"] = host_session_id
+        result = pm.launch_session(str(project))
+        if result.get("launched"):
+            return "launched"
+        return f"failed: {result.get('error', '')}".strip()
+    except Exception as exc:
+        log_hook_error("hook_session_open", exc)
+        return "error"
+
+
+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()
+    if start_source in _SILENT_SOURCES:
+        return None
+    project = find_project(payload, project_path)
+    if project is None:
+        return None
+    host = detect_host(payload)
+    host_sid = str(payload.get("session_id") or "").strip()
+    try:
+        from services.activity_log import ActivityLog
+        ActivityLog(str(project)).log("session_open", {
+            "host_session_id": host_sid,
+            "source": host,
+            "start_source": start_source,
+        })
+    except Exception as exc:
+        log_hook_error("hook_session_open", exc)
+    try:
+        from services.notifications import notify
+        notify(project, agent="session", severity="info",
+               title=f"Session started {short_id(host_sid)}",
+               message=(f"{host} session {host_sid or '?'} started"
+                        + (f" ({start_source})" if start_source else "")),
+               kind="session", ref_id=host_sid)
+    except Exception:
+        pass
+    ensure_ui(project, host_sid)
+    return None
+
+
+def main() -> None:
+    try:
+        data = json.load(sys.stdin)
+    except Exception as exc:
+        log_hook_error("hook_session_open", exc)
+        sys.exit(0)
+    try:
+        run(data)
+    except Exception as exc:
+        log_hook_error("hook_session_open", exc)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()