code-context-control 2.91.0__tar.gz → 2.92.1__tar.gz

{code_context_control-2.91.0/code_context_control.egg-info → code_context_control-2.92.1}/PKG-INFO

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

{code_context_control-2.91.0 → code_context_control-2.92.1}/cli/_hook_utils.py

@@ -7,6 +7,7 @@ All hook reads/writes of enforcement state MUST go through this module.
 """
 import json
 import os
+import re
 import sys
 import traceback
 from datetime import datetime, timezone
@@ -440,6 +441,43 @@ def get_tool_output(data: dict) -> tuple:
     return resp if isinstance(resp, str) else "", False
 
 
+# A c3 tool that failed did not read, search or edit anything, so its
+# completion is not evidence that c3 was used (field report 2026-08-22,
+# ISSUE-3: c3_compress on a missing path -> "Error: File not found" -> the
+# sticky unlock and the signal both fired -> native Write allowed). Tools
+# report failure as a leading "Error" / "[<tool>:error]" line, the masked-path
+# refusal tag, or an MCP isError flag.
+_FAILED_RESPONSE_RE = re.compile(
+    r"^\s*(?:Error\b|\[[a-z0-9_\-]+:error\]|\[c3-mask:unsupported\])", re.IGNORECASE)
+
+
+def response_text_failed(text) -> bool:
+    """True when a c3 tool's response text reads as a failure."""
+    return bool(_FAILED_RESPONSE_RE.match(str(text or "")))
+
+
+def tool_response_failed(data: dict) -> bool:
+    """True when the PostToolUse payload carries a failed c3 tool response.
+
+    Handles Claude Code's plain string, an MCP-style dict with ``isError`` /
+    ``content`` parts, a bare list of parts, and Gemini's ``llmContent``.
+    """
+    resp = data.get("tool_response")
+    if isinstance(resp, dict):
+        if resp.get("isError") is True or resp.get("is_error") is True:
+            return True
+        content = resp.get("content")
+        if isinstance(content, list):
+            text = "\n".join((p.get("text") or "") for p in content if isinstance(p, dict))
+            return response_text_failed(text)
+        text, _ = get_tool_output(data)
+        return response_text_failed(text)
+    if isinstance(resp, list):
+        text = "\n".join((p.get("text") or "") if isinstance(p, dict) else str(p) for p in resp)
+        return response_text_failed(text)
+    return response_text_failed(resp if isinstance(resp, str) else "")
+
+
 def get_tool_input_path(data: dict) -> str:
     """Extract file path from tool_input, handling Claude (file_path),
     Gemini (path), and NotebookEdit (notebook_path)."""

code_context_control-2.92.1/cli/_shell_writes.py

@@ -0,0 +1,120 @@
+"""Best-effort extraction of the files a shell command writes.
+
+Field report 2026-08-22, ISSUE-1's buried finding: ``Bash`` sits in the
+PreToolUse matcher, but tool discipline never looked at what a shell
+command does to files. An inline ``python -c`` write, ``cat > f <<EOF`` and
+``sed -i`` were never nudged toward c3_edit and never reached the ledger,
+so every agent that met a blocked ``Write`` simply went round it. This
+module is the one place that answers "which files does this command
+probably write?" for both the PreToolUse nudge (hook_pretool_enforce) and
+the after-the-fact ledger entry (hook_edit_ledger).
+
+Deliberately conservative, like the access guard's shell scan: a missed
+target costs one missing advisory line and one missing ledger row; a false
+target costs a misleading hint, so tokens that are shell syntax, streams
+(``/dev/null``, ``&1``) or pip-style ``>=`` version specs are skipped.
+Paths resolve against the directory the command runs in, following ``cd``.
+Never raises.
+"""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+_SEGMENT_SPLIT = re.compile(r"&&|\|\||[;\n]")
+_CD_RE = re.compile(r"""^\s*cd\s+(?:/d\s+)?(?P<dir>"[^"]+"|'[^']+'|\S+)\s*$""", re.IGNORECASE)
+# `>` / `>>` / `>|` preceded by whitespace or line start (so `foo>=3.0` is not a redirect).
+_REDIRECT_RE = re.compile(r"""(?:^|\s)\d?>{1,2}\|?\s*(?P<t>"[^"]+"|'[^']+'|\S+)""")
+_TEE_RE = re.compile(r"""(?:^|\|)\s*tee\s+(?:-[a-zA-Z]+\s+)*(?P<t>"[^"]+"|'[^']+'|\S+)""")
+_SED_INPLACE_RE = re.compile(r"""(?:^|\s)sed\s+(?P<rest>.*)$""")
+_PY_OPEN_RE = re.compile(r"""open\(\s*(?P<q>['"])(?P<t>[^'"]+)(?P=q)\s*,\s*['"][wax]""")
+_PY_WRITE_TEXT_RE = re.compile(r"""Path\(\s*(?P<q>['"])(?P<t>[^'"]+)(?P=q)\s*\)\s*\.write_(?:text|bytes)\(""")
+_FILE_CMDS = {"cp", "mv", "touch", "rm", "install"}
+_STREAMS = {"/dev/null", "/dev/stdout", "/dev/stderr", "nul", "&1", "&2", "-"}
+_SYNTAX = set("$`(){}|<>*?")
+MAX_TARGETS = 20
+
+
+def _clean(tok: str) -> str:
+    return tok.strip().strip("\"'`;,")
+
+
+def _skip(tok: str) -> bool:
+    if not tok or tok.startswith("-") or tok.startswith("=") or tok in _STREAMS:
+        return True
+    if tok.lower() in _STREAMS or tok.startswith("&"):
+        return True
+    return bool(_SYNTAX & set(tok))
+
+
+def _segment_targets(segment: str) -> list[str]:
+    out: list[str] = []
+    for m in _REDIRECT_RE.finditer(segment):
+        out.append(_clean(m.group("t")))
+    for m in _TEE_RE.finditer(segment):
+        out.append(_clean(m.group("t")))
+    for m in _PY_OPEN_RE.finditer(segment):
+        out.append(m.group("t"))
+    for m in _PY_WRITE_TEXT_RE.finditer(segment):
+        out.append(m.group("t"))
+    words = [w for w in re.split(r"\s+", segment.strip()) if w]
+    if words:
+        head = words[0].rsplit("/", 1)[-1].lower()
+        args = [_clean(w) for w in words[1:] if not w.startswith("-")]
+        if head in ("cp", "mv", "install") and len(args) >= 2:
+            out.append(args[-1])
+        elif head in ("touch", "rm") and args:
+            out.extend(args)
+        elif head == "sed":
+            flags = [w for w in words[1:] if w.startswith("-")]
+            if any(f.startswith("-i") or f == "--in-place" for f in flags):
+                # last non-flag, non-script argument(s): the files
+                files = [a for a in args if not (a.startswith("s/") or a.startswith("s|") or "/" in a and a.count("/") >= 2 and a.startswith("s"))]
+                out.extend(files[-2:] if files else [])
+    return [t for t in out if not _skip(t)]
+
+
+def _cd_target(segment: str, cwd: str) -> str | None:
+    m = _CD_RE.match(segment)
+    if not m:
+        return None
+    target = m.group("dir").strip("\"'")
+    try:
+        return target if os.path.isabs(target) else os.path.normpath(os.path.join(cwd, target))
+    except (OSError, ValueError):
+        return None
+
+
+def shell_write_targets(cmd: str, cwd: str) -> list[str]:
+    """Absolute paths the command probably writes, in order, de-duplicated.
+
+    ``cwd`` is the directory the command runs in (the project root for
+    Claude Code hooks). Relative targets resolve against it, and a ``cd``
+    segment moves it for the segments that follow.
+    """
+    found: list[str] = []
+    seen: set[str] = set()
+    here = cwd
+    try:
+        for segment in _SEGMENT_SPLIT.split(cmd or ""):
+            for tok in _segment_targets(segment):
+                if re.match(r"^/[a-z]/", tok):  # MSYS /c/foo -> C:/foo
+                    tok = f"{tok[1]}:{tok[2:]}"
+                try:
+                    p = Path(tok) if os.path.isabs(tok) else Path(here) / tok
+                    key = os.path.normcase(os.path.normpath(str(p)))
+                except (OSError, ValueError):
+                    continue
+                if key in seen:
+                    continue
+                seen.add(key)
+                found.append(str(p))
+                if len(found) >= MAX_TARGETS:
+                    return found
+            moved = _cd_target(segment, here)
+            if moved is not None:
+                here = moved
+    except Exception:
+        return found
+    return found

{code_context_control-2.91.0 → code_context_control-2.92.1}/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.91.0"
+__version__ = "2.92.1"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -845,7 +845,8 @@ def _prompt_memory_llm(project_path: str) -> None:
           + ("cloud + local fallback." if section["cloud_enabled"] else "local only (private)."))
 
 
-def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "direct") -> tuple[str, bool]:
+def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "direct",
+                       shape=None) -> tuple[str, bool]:
     """Run guided post-init setup steps for Git and MCP."""
     chosen_ide = _select_init_ide(ide_name or "auto")
     save_config({"ide": chosen_ide}, project_path)
@@ -916,7 +917,7 @@ def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "di
                 )
                 include_wildcard = bool(wildcard_choice and wildcard_choice.startswith("Yes"))
 
-    chosen_enforcement = _prompt_enforcement(chosen_tier)
+    chosen_enforcement = _prompt_enforcement(chosen_tier, shape=shape)
 
     _run_install_mcp(project_path, chosen_ide, mcp_mode=mcp_mode,
                      permissions=chosen_tier, include_mcp_wildcard=include_wildcard,
@@ -924,9 +925,70 @@ def _prompt_init_steps(project_path: str, ide_name: str, default_mode: str = "di
     return chosen_ide, True
 
 
-def _prompt_enforcement(chosen_tier: str | None) -> str | None:
+def _assess_repo_shape(project_path: str):
+    """Measure the project (services.repo_shape). None when it cannot be measured."""
+    try:
+        from services import repo_shape
+        return repo_shape.assess(project_path)
+    except Exception:
+        _log.debug("repo shape assessment failed", exc_info=True)
+        return None
+
+
+def _apply_repo_shape_default(project_path: str, explicit_enforcement: str | None = None,
+                              shape=None) -> None:
+    """Say what kind of project this is, and default a prose one to ``advisory``.
+
+    Field report 2026-08-22: a 636-file project, ~95% Markdown and .docx,
+    where every symbol-aware C3 tool had nothing to act on and strict
+    discipline was paid on every turn until C3 was uninstalled. The shape
+    is printed for every project; the default is written only for the prose
+    kind, only over a tier-derived or unset mode (never over ``c3 enforce``
+    or ``--enforcement``), with provenance ``set_by: repo-shape`` so
+    ``c3 enforce`` shows where it came from, and with the way back printed.
+    """
+    try:
+        from services import enforcement_policy as ep
+        from services import repo_shape
+    except Exception:
+        return
+    if shape is None:
+        shape = _assess_repo_shape(project_path)
+    if shape is None or shape.kind == repo_shape.KIND_EMPTY:
+        return
+    print(f"\n  Repo shape: {shape.describe()}")
+    mode = repo_shape.recommended_mode(shape)
+    if not mode:
+        return
+    if explicit_enforcement:
+        print(f"      Prose-heavy, but --enforcement {explicit_enforcement} was given — leaving it as set.")
+        return
+    current = ep.resolve(project_path)
+    if current.set_by == ep.SET_BY_USER:
+        print(f"      Prose-heavy; tool discipline stays '{current.mode}' (your choice).")
+        return
+    if current.mode == mode:
+        print(f"      Prose-heavy; tool discipline is already '{mode}'.")
+        return
+    try:
+        result = ep.set_mode(mode, project_path, set_by=ep.SET_BY_SHAPE, scope="project")
+    except ValueError:
+        return
+    if result.get("deferred"):
+        return
+    print("  [!] This is a documentation project: C3's symbol-aware tools (compress/read/impact/")
+    print(f"      validate/CI) have little to act on here, so tool discipline is set to '{mode}' —")
+    print("      native Edit/Write are allowed with a nudge and the edit ledger still records them.")
+    print("      `c3 enforce strict` restores the hard block; `c3 enforce` shows the setting.")
+
+
+def _prompt_enforcement(chosen_tier: str | None, shape=None) -> str | None:
     """Step 5/5 — tool discipline. Returns an explicit mode, or None to derive.
 
+    ``shape`` (services.repo_shape.RepoShape) moves the suggested default to
+    ``advisory`` for a documentation project and says why, so the user is
+    not asked to guess what C3's symbol tools will do with 600 Markdown files.
+
     Asked separately from the permission tier because it answers a genuinely
     different question: the tier controls what the IDE will let the agent call,
     this controls how hard C3's own hook pushes it toward c3_* tools. Users hit
@@ -938,8 +1000,18 @@ def _prompt_enforcement(chosen_tier: str | None) -> str | None:
         return None
 
     default_mode = ep.derive_from_tier(chosen_tier) if chosen_tier else ep.MODE_ADVISORY
+    suggested_by = "Your permission tier suggests"
+    try:
+        from services import repo_shape
+        shape_mode = repo_shape.recommended_mode(shape) if shape is not None else None
+    except Exception:
+        shape_mode = None
+    if shape_mode:
+        default_mode = shape_mode
+        suggested_by = ("This is a documentation project — C3's symbol tools have "
+                        "little to act on here. Suggested")
     print()
-    print(f"  (Your permission tier suggests: {default_mode})")
+    print(f"  ({suggested_by}: {default_mode})")
     choice = _prompt_choice(
         "Step 5/5 — Tool discipline: how hard should C3 push toward c3_* tools?",
         [
@@ -1085,6 +1157,7 @@ def cmd_init(args):
     if not c3_dir.exists() or not (c3_dir / "config.json").exists():
         print_header(f"Initializing C3 for: {project_path}")
         _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
+        shape = _assess_repo_shape(project_path)
         try:
             from services.project_manager import ProjectManager
             ProjectManager().add_project(project_path)
@@ -1101,7 +1174,11 @@ def cmd_init(args):
                 enforcement=getattr(args, "enforcement", None),
             )
         else:
-            _prompt_init_steps(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"))
+            _prompt_init_steps(project_path, requested_ide,
+                               default_mode=getattr(args, "mcp_mode", "direct"), shape=shape)
+        _apply_repo_shape_default(project_path,
+                                  explicit_enforcement=getattr(args, "enforcement", None),
+                                  shape=shape)
         # Detect Codex CLI availability
         try:
             from cli.tools.delegate import check_codex
@@ -1285,11 +1362,7 @@ def cmd_init(args):
         if c3_dir.exists():
             shutil.rmtree(c3_dir)
             print("  Deleted .c3/")
-        for filename, _ in _instruction_documents_for_project():
-            p = Path(project_path) / filename
-            if p.exists():
-                p.unlink()
-                print(f"  Deleted {filename}")
+        _remove_c3_instruction_docs(project_path)
         print("\n[OK] C3 project files removed.")
         return
 
@@ -1361,9 +1434,10 @@ def cmd_init(args):
 
     elif selected.startswith("Wipe"):
         confirm = input(
-            "\n  WARNING: This will permanently delete .c3/ and all project\n"
-            "  instruction files (CLAUDE.md, GEMINI.md, AGENTS.md), and remove\n"
-            "  C3 MCP configurations from your IDE. Type 'yes' to confirm: "
+            "\n  WARNING: This will permanently delete .c3/, remove C3's managed\n"
+            "  block from CLAUDE.md / AGENTS.md / GEMINI.md (a file is deleted only\n"
+            "  when nothing else is in it), and remove C3 MCP configurations from\n"
+            "  your IDE. Type 'yes' to confirm: "
         ).strip().lower()
         if confirm != "yes":
             print("  Wipe cancelled.")
@@ -1375,11 +1449,7 @@ def cmd_init(args):
             shutil.rmtree(c3_dir)
             print("  Deleted .c3/")
 
-        for filename, _ in _instruction_documents_for_project():
-            p = Path(project_path) / filename
-            if p.exists():
-                p.unlink()
-                print(f"  Deleted {filename}")
+        _remove_c3_instruction_docs(project_path)
 
         print("\n[OK] C3 project files removed.")
 
@@ -4555,6 +4625,115 @@ def _ensure_global_session_fallbacks(server_script: str, c3_mcp_exe: str | None
             print(f"Warning: Could not update {antigravity_path} (global fallback skipped)")
 
 
+# Every hook script C3 has ever registered in a settings file — the v2.42+
+# dispatcher plus the pre-v2.42 per-hook scripts — so uninstall recognises an
+# entry written by any C3 version. A user hook is anything not naming one.
+_C3_HOOK_SCRIPTS = (
+    "hook_dispatch.py",
+    "hook_access_guard.py", "hook_artifact.py", "hook_auto_snapshot.py",
+    "hook_c3_signal.py", "hook_c3read.py", "hook_edit_ledger.py",
+    "hook_edit_unlock.py", "hook_filter.py", "hook_ghost_files.py",
+    "hook_pretool_enforce.py", "hook_prompt_recall.py", "hook_read.py",
+    "hook_session_stats.py", "hook_terse_advisor.py",
+)
+
+
+def _is_c3_hook_command(command) -> bool:
+    return any(script in str(command or "") for script in _C3_HOOK_SCRIPTS)
+
+
+def _is_c3_permission(rule) -> bool:
+    """``mcp__c3__<tool>``, ``mcp__c3__*``, or the bare ``mcp__c3`` server grant."""
+    r = str(rule or "").strip()
+    return r == "mcp__c3" or r.startswith("mcp__c3__")
+
+
+def _c3_references_in_settings(settings: dict) -> list:
+    """Every C3-owned entry present in a settings dict: hook commands (named
+    by event) and permission rules. Used to decide whether there is anything
+    to remove and, after writing, to check that it was actually removed."""
+    refs: list = []
+    hooks = settings.get("hooks")
+    if isinstance(hooks, dict):
+        for event, groups in hooks.items():
+            for group in groups or []:
+                if not isinstance(group, dict):
+                    continue
+                for hk in group.get("hooks") or []:
+                    if isinstance(hk, dict) and _is_c3_hook_command(hk.get("command")):
+                        refs.append(f"hooks.{event}")
+    perms = settings.get("permissions")
+    if isinstance(perms, dict):
+        for key in ("allow", "deny", "ask"):
+            for rule in perms.get(key) or []:
+                if _is_c3_permission(rule):
+                    refs.append(f"permissions.{key}:{rule}")
+    if "c3" in (settings.get("enabledMcpjsonServers") or []):
+        refs.append("enabledMcpjsonServers:c3")
+    return refs
+
+
+def _strip_c3_from_settings(settings: dict) -> dict:
+    """Remove every C3-owned entry from a Claude Code settings dict (in place,
+    and returned). Touches ONLY what C3 wrote: hook entries whose command runs
+    a C3 hook script — any event, any matcher; the previous cleanup looked at
+    three PostToolUse matchers from the pre-v2.42 layout and nothing else, so
+    PreToolUse/Stop/UserPromptSubmit and the whole ``permissions.allow`` list
+    survived an "uninstall" — plus ``mcp__c3__*`` permission rules and the
+    ``c3`` MCP-server enablement. User hooks, user permission rules and every
+    other key are left exactly as found; containers emptied by the removal
+    are dropped so a file C3 created alone ends up empty (and the caller
+    deletes it) rather than as ``{"hooks": {}}``.
+    """
+    hooks = settings.get("hooks")
+    if isinstance(hooks, dict):
+        for event in list(hooks.keys()):
+            kept_groups = []
+            for group in hooks.get(event) or []:
+                if not isinstance(group, dict):
+                    kept_groups.append(group)
+                    continue
+                entries = group.get("hooks") or []
+                if not any(isinstance(hk, dict) and _is_c3_hook_command(hk.get("command"))
+                           for hk in entries):
+                    kept_groups.append(group)  # not ours — untouched
+                    continue
+                kept = [hk for hk in entries
+                        if not (isinstance(hk, dict) and _is_c3_hook_command(hk.get("command")))]
+                if kept:
+                    group = dict(group)
+                    group["hooks"] = kept
+                    kept_groups.append(group)
+            if kept_groups:
+                hooks[event] = kept_groups
+            else:
+                del hooks[event]
+        if not hooks:
+            del settings["hooks"]
+
+    perms = settings.get("permissions")
+    if isinstance(perms, dict):
+        for key in ("allow", "deny", "ask"):
+            rules = perms.get(key)
+            if isinstance(rules, list) and any(_is_c3_permission(r) for r in rules):
+                kept_rules = [r for r in rules if not _is_c3_permission(r)]
+                if kept_rules:
+                    perms[key] = kept_rules
+                else:
+                    del perms[key]
+        if not perms:
+            del settings["permissions"]
+
+    enabled = settings.get("enabledMcpjsonServers")
+    if isinstance(enabled, list) and "c3" in enabled:
+        enabled = [s for s in enabled if s != "c3"]
+        if enabled:
+            settings["enabledMcpjsonServers"] = enabled
+        else:
+            del settings["enabledMcpjsonServers"]
+    return settings
+
+
 def _uninstall_mcp_all(project_path: str, include_global: bool = True):
     """Remove C3 MCP server configurations from all supported IDEs.
 
@@ -4658,37 +4837,28 @@ def _uninstall_mcp_all(project_path: str, include_global: bool = True):
                     with open(settings_path, 'r', encoding="utf-8") as f:
                         settings = json.load(f)
 
-                    # Remove hooks
-                    hooks = settings.get("hooks", {}).get("PostToolUse", [])
-                    new_hooks = []
-                    c3_hook_files = {"hook_filter.py", "hook_read.py", "hook_c3read.py", "hook_dispatch.py"}
-                    for h in hooks:
-                        if h.get("matcher") in ("Bash", "Read", "mcp__c3__c3_read"):
-                            h["hooks"] = [hook for hook in h.get("hooks", [])
-                                          if not any(f in hook.get("command", "") for f in c3_hook_files)]
-                            if h["hooks"]:
-                                new_hooks.append(h)
-                        else:
-                            new_hooks.append(h)
-
-                    if new_hooks:
-                        settings["hooks"]["PostToolUse"] = new_hooks
-                    elif "hooks" in settings and "PostToolUse" in settings["hooks"]:
-                        del settings["hooks"]["PostToolUse"]
-                        if not settings["hooks"]:
-                            del settings["hooks"]
-
-                    # Remove enabled server
-                    if "enabledMcpjsonServers" in settings and "c3" in settings["enabledMcpjsonServers"]:
-                        settings["enabledMcpjsonServers"].remove("c3")
-
-                    if not settings:
-                        settings_path.unlink()
-                        print(f"  Deleted empty {settings_path}")
+                    before = _c3_references_in_settings(settings)
+                    if not before:
+                        print(f"  No C3 entries in {settings_path}")
                     else:
-                        with open(settings_path, 'w', encoding="utf-8") as f:
-                            json.dump(settings, f, indent=2)
-                        print(f"  Removed C3 hooks/settings from {settings_path}")
+                        settings = _strip_c3_from_settings(settings)
+                        if not settings:
+                            settings_path.unlink()
+                            print(f"  Deleted empty {settings_path}")
+                        else:
+                            with open(settings_path, 'w', encoding="utf-8") as f:
+                                json.dump(settings, f, indent=2)
+                            # Postcondition: re-read what is on disk and report
+                            # what is true, not what was attempted.
+                            with open(settings_path, 'r', encoding="utf-8") as f:
+                                remaining = _c3_references_in_settings(json.load(f))
+                            if remaining:
+                                shown = ", ".join(remaining[:5]) + (" ..." if len(remaining) > 5 else "")
+                                print(f"  [!] C3 entries remain in {settings_path} "
+                                      f"({len(remaining)}): {shown}")
+                            else:
+                                print(f"  Removed C3 hooks/settings from {settings_path} "
+                                      f"({len(before)} entries)")
                 except Exception as e:
                     print(f"  Warning: Could not update {settings_path}: {e}")
 
@@ -4872,6 +5042,44 @@ def _instruction_documents_for_project() -> list[tuple[str, str]]:
     ]
 
 
+def _remove_c3_instruction_docs(project_path: str) -> None:
+    """Take C3's managed block OUT of every instruction doc it ever wrote.
+
+    Uninstall counterpart of ``_sync_project_instruction_docs``. Before
+    v2.92 this was a bare ``unlink()`` of CLAUDE.md / AGENTS.md / GEMINI.md —
+    which, in a project whose CLAUDE.md also carried another tool's managed
+    block (``<!-- YEP:BEGIN -->``) or the user's own notes, destroyed content
+    C3 never owned, with no warning and no way back unless git had it.
+    Same rule every regeneration path already follows: C3 owns its slice,
+    everything outside the markers is preserved. A file is deleted only when
+    the block was all there was.
+    """
+    from services.claude_md import strip_c3_block
+
+    for filename, _ in _instruction_documents_for_project():
+        p = Path(project_path) / filename
+        if not p.exists():
+            continue
+        try:
+            existing = p.read_text(encoding="utf-8", errors="replace")
+        except OSError as exc:
+            print(f"  Warning: Could not read {filename}: {exc}")
+            continue
+        remainder = strip_c3_block(existing)
+        if remainder is None:
+            print(f"  Kept {filename} (no C3 block in it — not ours to delete)")
+        elif remainder.strip():
+            try:
+                p.write_text(remainder, encoding="utf-8")
+            except OSError as exc:
+                print(f"  Warning: Could not update {filename}: {exc}")
+                continue
+            print(f"  Removed C3 block from {filename} (kept the rest of the file)")
+        else:
+            p.unlink()
+            print(f"  Deleted {filename}")
+
+
 _LEGACY_INSTRUCTION_DOCS = ("GEMINI.md",)  # Gemini CLI profile removed in v2.52
 
 

{code_context_control-2.91.0 → code_context_control-2.92.1}/cli/guide/oracle.html

@@ -330,10 +330,10 @@ curl -X POST \
           <tr><td><code>c3 oracle serve --install</code></td>   <td>Register the Oracle as a login/startup service — no terminal window — and start it now. Windows: Task Scheduler (Run-key fallback); macOS: launchd; Linux: systemd user unit</td></tr>
           <tr><td><code>c3 oracle serve --uninstall</code></td> <td>Remove the startup registration (a running Oracle keeps running)</td></tr>
           <tr><td><code>c3 oracle serve --status</code></td>    <td>Installed? Running? Port, bind host, URL, and the launcher log path</td></tr>
-          <tr><td><code>c3 oracle open</code></td>       <td>Sign in to a running dashboard via a single-use URL</td></tr>
+          <tr><td><code>c3 oracle open</code></td>       <td>Sign in to a running dashboard via a single-use URL (the hub's <strong>Open Oracle</strong> button does the same thing)</td></tr>
         </tbody>
       </table>
-      <p style="font-size: 12px; color: var(--text-dim); margin: 8px 0 0;">The Hub exposes the same controls under <strong>Settings → Oracle service</strong> (Install / Uninstall / Start / Stop / Open). Starting the Oracle from there also fills in the Hub's <em>Oracle URL</em> when it is empty, so the Open Oracle button appears in the top bar.</p>
+      <p style="font-size: 12px; color: var(--text-dim); margin: 8px 0 0;">The Hub exposes the same controls under <strong>Settings → Oracle service</strong> (Install / Uninstall / Start / Stop / Open). Starting the Oracle from there also fills in the Hub's <em>Oracle URL</em> when it is empty, so the Open Oracle button appears in the top bar. That button opens a <strong>signed-in</strong> dashboard: it redeems the Oracle's owner-only bootstrap key for you. Reaching the dashboard by pasting its URL instead leaves it read-only — the page renders and the header looks healthy, but chat, Save and Test Ollama answer <code>401 unauthorized</code>.</p>
     </section>
 
     <hr class="divider">

{code_context_control-2.91.0 → code_context_control-2.92.1}/cli/hook_c3_signal.py

@@ -26,7 +26,7 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from cli._hook_utils import log_hook_error, record_c3_signal  # noqa: E402
+from cli._hook_utils import log_hook_error, record_c3_signal, tool_response_failed  # noqa: E402
 
 # Tools that unlock generic read operations (Grep/Glob without a file path)
 _READ_UNLOCK_TOOLS = {"c3_search", "c3_compress", "c3_filter", "c3_read", "c3_impact", "c3_validate"}
@@ -45,6 +45,10 @@ def run(payload: dict, project_path: Path | None = None):
     if not short_name.startswith("c3_"):
         return None
 
+    # A failed call read nothing and edited nothing: no signal (ISSUE-3).
+    if tool_response_failed(payload):
+        return None
+
     record_c3_signal(
         short_name,
         short_name in _READ_UNLOCK_TOOLS,

{code_context_control-2.91.0 → code_context_control-2.92.1}/cli/hook_dispatch.py

@@ -152,6 +152,10 @@ def _routes(event: str, raw_tool: str, norm_tool: str, host: str = HOST_CLAUDE):
             yield "hook_artifact"
         if raw_tool in _GHOST_TOOLS:
             yield "hook_ghost_files"
+        # Shell file writes land in the ledger after the fact (after the
+        # ghost sweep, so a 0-byte redirect artifact is never logged).
+        if norm_tool == "Bash":
+            yield "hook_edit_ledger"
     elif event == "stop":
         yield "hook_session_stats"
         yield "hook_auto_snapshot"