code-context-control 2.73.0__tar.gz → 2.74.0__tar.gz

{code_context_control-2.73.0/code_context_control.egg-info → code_context_control-2.74.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.73.0
+Version: 2.74.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.73.0 → code_context_control-2.74.0}/cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.73.0"
+__version__ = "2.74.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):

{code_context_control-2.73.0 → code_context_control-2.74.0/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.73.0
+Version: 2.74.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.73.0 → code_context_control-2.74.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.73.0"
+version = "2.74.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.73.0 → code_context_control-2.74.0}/services/access_guard.py

@@ -709,11 +709,12 @@ def _override_offer(denial: Denial, path, operation: str, tool: str) -> str:
     that can never be escalated: an agent must not learn from a refusal that
     a request surface exists for the credential vault (§6).
 
-    Restricted to the hook surface on purpose. The offer promises that a human
-    'yes' makes the retry work, and today only the PreToolUse gates consult
-    grants — the ``c3_*`` content surfaces do not (see §13, phase P2a). An
-    offer on a surface that would still refuse after approval is worse than
-    no offer.
+    Restricted to the hook surface on purpose — see ``refusal``. The rule was
+    written when only the PreToolUse gates consulted grants; P2a taught the
+    ``c3_*`` content surfaces to consult them too, so extending the offer to
+    the MCP surface is now defensible. It is deliberately NOT done here: that
+    is a separate, wider change (every c3_* refusal grows a line) and belongs
+    in its own review, not smuggled in beside a fix for the branch ordering.
     """
     try:
         from services import override_policy as _op  # noqa: PLC0415 — cycle
@@ -738,7 +739,26 @@ def refusal(denial: Denial, path, operation: str, *, surface: str = "mcp",
     the agent it may ASK (docs/override-requests.md §6). The pinned strings
     above are unchanged: the append is absent unless the project opted in,
     which is off by default.
+
+    The append happens HERE, once, for every kind — not inside a branch. It
+    used to live at the tail of the deny branch, which sits below the mask and
+    read-only early returns, so those two kinds could never carry an offer on
+    any surface even though `rule_class_for_denial` marks both escalatable.
+    `access_readonly` was the only layer anyone had turned on, so in practice
+    the invitation half of Override Requests had never fired once.
     """
+    body = _refusal_body(denial, path, operation, surface=surface,
+                         tool=tool, project=project)
+    # Hook only, still: the offer promises that a 'yes' makes the retry work,
+    # and the proxy surface answers for a DIFFERENT project's policy.
+    if surface == "hook":
+        return body + _override_offer(denial, path, operation, tool)
+    return body
+
+
+def _refusal_body(denial: Denial, path, operation: str, *, surface: str,
+                  tool: str, project: str) -> str:
+    """The pinned string itself, with no override append."""
     p, glob, scope = _cap(path), denial.rule, denial.scope
     if denial.kind == _KIND_MASK:
         if operation in ("write", "create", "delete"):
@@ -762,12 +782,20 @@ def refusal(denial: Denial, path, operation: str, *, surface: str = "mcp",
             "`c3 access list` or the Access tab."
         )
     if denial.kind == _KIND_READ_ONLY:
+        # `{operation}`, not a hardcoded "write". A read-only rule blocks the
+        # whole write class, and for a file that does not exist yet the tools
+        # call that operation `create`. Saying "write" told the agent to ask
+        # the user to approve `op='write'`, the approval was minted for
+        # `write`, and the grant matcher — which compares op exactly — then
+        # refused the `create` the tool actually attempted. A real approval
+        # was spent and silently discarded (§4 near_miss).
         return (
-            f"{TAG_READ_ONLY} write denied for {p} by Access Guard rule "
+            f"{TAG_READ_ONLY} {operation} denied for {p} by Access Guard rule "
             f"'{glob}' ({scope} scope). The effective policy is read-only; "
-            "reads are evaluated separately. Do not retry the write. Mark "
-            "the affected step blocked and continue with unaffected files; "
-            "report the skip. Rules: `c3 access list` or the Access tab."
+            f"reads are evaluated separately. Do not retry the {operation}. "
+            "Mark the affected step blocked and continue with unaffected "
+            "files; report the skip. Rules: `c3 access list` or the Access "
+            "tab."
         )
     if surface == "hook":
         return (
@@ -776,7 +804,7 @@ def refusal(denial: Denial, path, operation: str, *, surface: str = "mcp",
             "decision, not a transient error — do not retry through another "
             "tool or the shell. Mark the affected step blocked and continue "
             "with unaffected files. Rules: `c3 access list`."
-        ) + _override_offer(denial, path, operation, tool)
+        )
     if surface == "proxy":
         return (
             f"{TAG_DENIED} {operation} denied for {p} through project "

{code_context_control-2.73.0 → code_context_control-2.74.0}/services/notifications.py

@@ -43,7 +43,8 @@ class NotificationStore:
         self._collapsed = False
 
     def add(self, agent: str, severity: str, title: str, message: str,
-            ai_enhanced: bool = False, replace_if_unacked: bool = False) -> dict | None:
+            ai_enhanced: bool = False, replace_if_unacked: bool = False,
+            kind: str = "", ref_id: str = "") -> dict | None:
         """Append a notification. Dedup: an identical (agent, title, message)
         that is still unacknowledged collapses into the existing record — its
         ``count`` is bumped and ``last_seen`` refreshed instead of appending a
@@ -54,6 +55,13 @@ class NotificationStore:
             already exists, update its message/severity in-place (bumping
             count/last_seen) instead of appending a new entry. Use for
             high-frequency agents (budget, index, key-file drift) to prevent pile-up.
+        kind: machine-readable class for clients that ROUTE on a tap rather
+            than parse the title — 'override' for an approval request. Omitted
+            from the record when empty, so every existing producer and every
+            stored line is unchanged.
+        ref_id: the id of the thing the notification is ABOUT (e.g. the
+            override request), which is not the notification's own ``id``.
+            A client needs both: ``id`` to acknowledge, ``ref_id`` to navigate.
         Returns the entry if written/updated, None if deduped.
         """
         with self._lock:
@@ -75,6 +83,13 @@ class NotificationStore:
                         existing["last_seen"] = now.isoformat()
                         existing["count"] = _entry_count(existing) + 1
                         existing["ai_enhanced"] = ai_enhanced
+                        # Refresh the routing fields too: an in-place update
+                        # keeps the record but the thing it points AT may have
+                        # changed (a new request id under the same title).
+                        if kind:
+                            existing["kind"] = kind
+                        if ref_id:
+                            existing["ref_id"] = ref_id
                         self._write_all(entries)
                         return existing
                     # Same notification still pending — collapse into the
@@ -108,6 +123,12 @@ class NotificationStore:
                 "acknowledged": False,
                 "ai_enhanced": ai_enhanced,
             }
+            # Additive only: absent keys rather than empty ones, so a client
+            # can test presence and old lines stay byte-identical in shape.
+            if kind:
+                entry["kind"] = kind
+            if ref_id:
+                entry["ref_id"] = ref_id
             with open(self._file, "a", encoding="utf-8") as f:
                 f.write(json.dumps(entry) + "\n")
             return entry

{code_context_control-2.73.0 → code_context_control-2.74.0}/services/override_requests.py

@@ -420,6 +420,12 @@ def _notify(project_path: str, row: dict, policy) -> None:
                   f"{Path(row['path']).name}?",
             message=(f"Blocked by rule {row['rule']} ({row['rule_class']}). "
                      f"Approve once: c3 override approve {row['id']}"),
+            # A phone routes on these, not on the title. Without them a tap
+            # opens the app and drops the user wherever they were last —
+            # which, for the one notification that exists to be answered, is
+            # the same as not delivering it (§9).
+            kind="override",
+            ref_id=row["id"],
         )
     except Exception:
         pass  # a missing notification must never fail the request

{code_context_control-2.73.0 → code_context_control-2.74.0}/tests/test_override_requests.py

@@ -325,5 +325,130 @@ class TestOfferLine(RequestBase):
         self.assertIn("do not retry through another tool or the shell", text)
 
 
+# ── §6 the offer must not depend on WHICH kind denied ──────────────────────
+
+class TestOfferReachesEveryEscalatableKind(RequestBase):
+    """The bug this class exists for.
+
+    `refusal()` used to append the offer at the tail of the deny branch, which
+    sits *below* the mask and read-only early returns. Both of those kinds map
+    to an escalatable layer in `rule_class_for_denial`, so policy said "offer
+    this" and the composer structurally could not. `access_readonly` was the
+    only layer that had ever been switched on in the wild, which made the
+    invitation half of the feature dead on the one path anybody used.
+
+    These assert on the LAYER, not on a branch, so re-introducing an early
+    return in front of the append fails here rather than in production.
+    """
+
+    def _refuse(self, rel, operation, tool="Write"):
+        target = self.proj / rel
+        target.parent.mkdir(parents=True, exist_ok=True)
+        denial = ag.check(str(target), operation, str(self.proj))
+        self.assertIsNotNone(denial, f"fixture must deny {rel} on {operation}")
+        return denial, ag.refusal(denial, str(target), operation,
+                                  surface="hook", tool=tool)
+
+    def test_read_only_denial_carries_the_offer(self):
+        denial, text = self._refuse("docs/a.md", "write")
+        self.assertEqual(denial.kind, "read_only")
+        self.assertEqual(opol.rule_class_for_denial(denial),
+                         opol.LAYER_ACCESS_READONLY)
+        self.assertIn(opol.TAG_OFFER, text)
+        self.assertIn("action='request'", text)
+
+    def test_deny_denial_still_carries_the_offer(self):
+        denial, text = self._refuse("secrets/other.txt", "read", tool="Read")
+        self.assertEqual(denial.kind, "deny")
+        self.assertIn(opol.TAG_OFFER, text)
+
+    def test_every_escalatable_kind_is_offered(self):
+        """No kind may be silently unreachable."""
+        cases = [("docs/a.md", "write"), ("secrets/other.txt", "read")]
+        for rel, operation in cases:
+            with self.subTest(path=rel):
+                denial, text = self._refuse(rel, operation)
+                layer = opol.rule_class_for_denial(denial)
+                self.assertIsNotNone(layer)
+                self.assertIn(opol.TAG_OFFER, text)
+
+    def test_offer_still_absent_when_the_layer_is_off(self):
+        layers = dict(ALL_LAYERS_ON)
+        layers[opol.LAYER_ACCESS_READONLY] = False
+        self.write_config(layers=layers)
+        _, text = self._refuse("docs/a.md", "write")
+        self.assertNotIn(opol.TAG_OFFER, text)
+
+    def test_offer_absent_on_the_mcp_surface(self):
+        denial = ag.check(str(self.proj / "docs" / "a.md"), "write",
+                          str(self.proj))
+        text = ag.refusal(denial, "docs/a.md", "write")
+        self.assertNotIn(opol.TAG_OFFER, text)
+
+
+# ── §4 the refusal must name the operation the caller named ────────────────
+
+class TestRefusalNamesTheRealOperation(RequestBase):
+    """A read-only refusal that always said "write" cost a real approval.
+
+    `c3_edit` calls the operation `create` when the file does not exist. The
+    agent copied "write" out of the refusal, the human approved `write`, and
+    the grant matcher — exact on `op` — refused the `create` that followed.
+    """
+
+    def _text(self, operation):
+        target = self.proj / "docs" / "new.md"
+        denial = ag.check(str(target), operation, str(self.proj))
+        return ag.refusal(denial, str(target), operation)
+
+    def test_create_is_named_create(self):
+        text = self._text("create")
+        self.assertIn("create denied", text)
+        self.assertNotIn("write denied", text)
+        self.assertIn("Do not retry the create", text)
+
+    def test_write_is_still_named_write(self):
+        text = self._text("write")
+        self.assertIn("write denied", text)
+
+    def test_delete_is_named_delete(self):
+        self.assertIn("delete denied", self._text("delete"))
+
+    def test_the_offer_carries_the_same_operation(self):
+        target = self.proj / "docs" / "new.md"
+        denial = ag.check(str(target), "create", str(self.proj))
+        text = ag.refusal(denial, str(target), "create", surface="hook",
+                          tool="c3_edit")
+        self.assertIn("op='create'", text)
+        self.assertNotIn("op='write'", text)
+
+
+# ── §9 the phone routes on the payload, not on the title ───────────────────
+
+class TestNotificationPayload(RequestBase):
+    def _entries(self):
+        raw = (self.proj / ".c3" / "notifications.jsonl").read_text("utf-8")
+        return [json.loads(ln) for ln in raw.splitlines() if ln.strip()]
+
+    def test_request_notification_carries_kind_and_ref_id(self):
+        row = self.request()
+        entry = next(e for e in self._entries()
+                     if e.get("title", "").startswith("Approve "))
+        self.assertEqual(entry["kind"], "override")
+        self.assertEqual(entry["ref_id"], row["id"])
+        # The notification's own id stays its own — a client needs both, one
+        # to acknowledge and one to navigate.
+        self.assertNotEqual(entry["id"], row["id"])
+
+    def test_other_producers_are_unchanged(self):
+        from services.notifications import NotificationStore
+        NotificationStore(str(self.proj)).add(
+            agent="IndexStaleness", severity="info", title="t", message="m")
+        entry = next(e for e in self._entries() if e.get("agent") ==
+                     "IndexStaleness")
+        self.assertNotIn("kind", entry)
+        self.assertNotIn("ref_id", entry)
+
+
 if __name__ == "__main__":
     unittest.main()