code-context-control 2.39.0__tar.gz → 2.40.0__tar.gz

{code_context_control-2.39.0/code_context_control.egg-info → code_context_control-2.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.39.0
+Version: 2.40.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -283,9 +283,12 @@ Access Token. Tokens live in the **OS keyring** (Windows Credential Manager,
 macOS Keychain, Linux Secret Service) — never in `.c3/config.json`.
 
 ```bash
-# One-time login per server
+# One-time login per server (stored under this project's .c3/config.json)
 c3 bitbucket login --url https://bitbucket.example.com
-#  → prompts for username + PAT (masked)
+#  -> prompts for username + PAT (masked)
+
+# ...or store it globally so every C3 project can use it
+c3 bitbucket login --global --url https://bitbucket.example.com
 
 # Pin defaults so subsequent calls don't need project/repo
 c3 bitbucket set-default --project PROJ --repo my-service
@@ -294,6 +297,16 @@ c3 bitbucket set-default --project PROJ --repo my-service
 c3 bitbucket status
 ```
 
+**Account resolution precedence:** the project's `.c3/config.json` wins, but when
+it has no active account C3 falls back to the global `~/.c3/config.json`. So a
+single `login --global` (or any login done from your home directory) is reusable
+across every C3 project — the PAT always lives in the OS keyring, never on disk.
+
+> **Upgrading:** stop the running `c3-mcp` server / CLI before `c3 upgrade`. A live
+> process can hold package files open, leaving pip's `~`-prefixed backup dirs
+> (`~ervices`, `~ools`, …) in `site-packages`; those are inert and safe to delete
+> after the upgrade completes.
+
 The MCP tool dispatches by `action`. Read-only actions: `status`, `whoami`,
 `list_projects`, `list_repos`, `get_repo`, `list_prs`, `get_pr`, `get_pr_diff`,
 `get_pr_activities`, `list_branches`, `list_commits`, `list_activity`,

{code_context_control-2.39.0 → code_context_control-2.40.0}/README.md

@@ -221,9 +221,12 @@ Access Token. Tokens live in the **OS keyring** (Windows Credential Manager,
 macOS Keychain, Linux Secret Service) — never in `.c3/config.json`.
 
 ```bash
-# One-time login per server
+# One-time login per server (stored under this project's .c3/config.json)
 c3 bitbucket login --url https://bitbucket.example.com
-#  → prompts for username + PAT (masked)
+#  -> prompts for username + PAT (masked)
+
+# ...or store it globally so every C3 project can use it
+c3 bitbucket login --global --url https://bitbucket.example.com
 
 # Pin defaults so subsequent calls don't need project/repo
 c3 bitbucket set-default --project PROJ --repo my-service
@@ -232,6 +235,16 @@ c3 bitbucket set-default --project PROJ --repo my-service
 c3 bitbucket status
 ```
 
+**Account resolution precedence:** the project's `.c3/config.json` wins, but when
+it has no active account C3 falls back to the global `~/.c3/config.json`. So a
+single `login --global` (or any login done from your home directory) is reusable
+across every C3 project — the PAT always lives in the OS keyring, never on disk.
+
+> **Upgrading:** stop the running `c3-mcp` server / CLI before `c3 upgrade`. A live
+> process can hold package files open, leaving pip's `~`-prefixed backup dirs
+> (`~ervices`, `~ools`, …) in `site-packages`; those are inert and safe to delete
+> after the upgrade completes.
+
 The MCP tool dispatches by `action`. Read-only actions: `status`, `whoami`,
 `list_projects`, `list_repos`, `get_repo`, `list_prs`, `get_pr`, `get_pr_diff`,
 `get_pr_activities`, `list_branches`, `list_commits`, `list_activity`,

{code_context_control-2.39.0 → code_context_control-2.40.0}/cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.39.0"
+__version__ = "2.40.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -5577,14 +5577,19 @@ def _bb_cmd_login(args, project_path: str) -> None:
     from services import bitbucket_credentials as bb_creds
     from services.bitbucket_client import BitbucketDataCenterClient, BitbucketError
 
+    # --global stores the account in ~/.c3/config.json so it is reusable in
+    # every C3 project (load_bitbucket_config falls back to it automatically).
+    if getattr(args, "use_global", False):
+        project_path = str(Path.home())
+
     base_url = (args.url or "").rstrip("/")
     username = args.username or input(f"Username for {base_url}: ").strip()
     if not username:
-        print("Login cancelled — username required.")
+        print("Login cancelled -- username required.")
         return
     token = args.token or getpass.getpass(f"Personal Access Token for {username}: ").strip()
     if not token:
-        print("Login cancelled — token required.")
+        print("Login cancelled -- token required.")
         return
 
     try:
@@ -5600,10 +5605,13 @@ def _bb_cmd_login(args, project_path: str) -> None:
     if getattr(args, "insecure", False):
         bb_creds.set_verify_tls(False, project_path=project_path)
 
-    print(f"[OK] Stored credentials for {username}@{base_url}")
+    scope = "global (~/.c3)" if getattr(args, "use_global", False) else "project"
+    print(f"[OK] Stored credentials for {username}@{base_url} [{scope}]")
 
-    # Connection probe — non-fatal if it fails (token might be valid but
-    # network blocked at this moment).
+    # Connection probe -- non-fatal if it fails (token might be valid but the
+    # network is blocked right now). Gate success on application-properties
+    # only; whoami enrichment is best-effort so a valid login never prints a
+    # failure (Bitbucket DC has no /users/me).
     try:
         client = BitbucketDataCenterClient(
             base_url=base_url, token=token,
@@ -5611,12 +5619,20 @@ def _bb_cmd_login(args, project_path: str) -> None:
         )
         props = client.application_properties()
         version = props.get("version", "?")
-        user = client.whoami()
         print(f"     Server: {version} ({base_url})")
-        print(f"     Auth as: {user.get('displayName', username)} <{user.get('emailAddress', '?')}>")
     except BitbucketError as exc:
         print(f"[warn] Connection probe failed: {exc}")
-        print("       Token saved anyway — re-test with `c3 bitbucket status`.")
+        print("       Token saved anyway -- re-test with `c3 bitbucket status`.")
+        return
+    try:
+        user = client.whoami()
+        if user:
+            print(
+                f"     Auth as: {user.get('displayName', username)} "
+                f"<{user.get('emailAddress', '?')}>"
+            )
+    except BitbucketError:
+        pass
 
 
 def _bb_cmd_logout(args, project_path: str) -> None:
@@ -5661,7 +5677,7 @@ def _bb_cmd_status(args, project_path: str) -> None:
         return
     token = bb_creds.load_token(active["base_url"], active["username"])
     if not token:
-        print("  Connection: FAIL — no token in keyring")
+        print("  Connection: FAIL -- no token in keyring")
         return
     try:
         client = BitbucketDataCenterClient(
@@ -5671,7 +5687,7 @@ def _bb_cmd_status(args, project_path: str) -> None:
         props = client.application_properties()
         print(f"  Connection: OK (version {props.get('version','?')})")
     except BitbucketError as exc:
-        print(f"  Connection: FAIL — {exc}")
+        print(f"  Connection: FAIL -- {exc}")
 
 
 def _bb_cmd_use(args, project_path: str) -> None:
@@ -6571,6 +6587,15 @@ def _launch_tui() -> None:
 
 
 def main():
+    # Force UTF-8 on the CLI streams so server-supplied text (PR titles, branch
+    # names, diffs) and our own glyphs render cleanly on Windows cp1252 consoles
+    # instead of raising UnicodeEncodeError or mojibaking.
+    for _stream in (sys.stdout, sys.stderr):
+        try:
+            _stream.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
     try:
         from services import error_reporting
         error_reporting.init(component="c3-cli", version=__version__)

{code_context_control-2.39.0 → code_context_control-2.40.0}/cli/commands/parser.py

@@ -303,6 +303,7 @@ def build_parser(version: str, parse_cli_ide_arg):
     bb_login.add_argument("--token", help="Personal Access Token (prompted via getpass if omitted — preferred)")
     bb_login.add_argument("--no-set-active", action="store_true", help="Do not switch the active account to this one")
     bb_login.add_argument("--insecure", action="store_true", help="Disable TLS verification (self-signed certs)")
+    bb_login.add_argument("--global", dest="use_global", action="store_true", help="Store the account in the global ~/.c3/config.json so it is reusable in every C3 project")
     bb_login.add_argument("project_path", nargs="?", default=".")
 
     bb_logout = bb_subs.add_parser("logout", help="Remove a Bitbucket account from keyring + config")

{code_context_control-2.39.0 → code_context_control-2.40.0}/cli/tools/bitbucket.py

@@ -50,7 +50,12 @@ def _cap(resp: str) -> str:
         candidate = "\n".join(lines) + "\n[truncated]"
         if count_tokens(candidate) <= _RESPONSE_TOKEN_CAP:
             return candidate
-    return "\n".join(lines[:20]) + "\n[truncated]"
+    # A single over-long line never splits above; hard-clamp by characters as a
+    # final guard (~4 chars/token) so one huge line can't blow past the cap.
+    head = "\n".join(lines[:20])
+    if count_tokens(head) > _RESPONSE_TOKEN_CAP:
+        head = head[:_RESPONSE_TOKEN_CAP * 4]
+    return head + "\n[truncated]"
 
 
 def _build_client(svc) -> tuple[BitbucketDataCenterClient | None, str]:
@@ -111,20 +116,20 @@ def _format_pr(pr: dict) -> str:
     author = (pr.get("author") or {}).get("user", {}).get("name", "?")
     src = (pr.get("fromRef") or {}).get("displayId", "?")
     dst = (pr.get("toRef") or {}).get("displayId", "?")
-    return f"  #{pr_id} [{state:7}] {src} → {dst}  by {author}\n         {title}"
+    return f"  #{pr_id} [{state:7}] {src} -> {dst}  by {author}\n         {title}"
 
 
 def _format_pr_full(pr: dict) -> str:
     lines = [
-        f"PR #{pr.get('id')} [{pr.get('state')}] — {pr.get('title','')}",
-        f"  {(pr.get('fromRef') or {}).get('displayId')} → {(pr.get('toRef') or {}).get('displayId')}",
+        f"PR #{pr.get('id')} [{pr.get('state')}] -- {pr.get('title','')}",
+        f"  {(pr.get('fromRef') or {}).get('displayId')} -> {(pr.get('toRef') or {}).get('displayId')}",
         f"  Author: {(pr.get('author') or {}).get('user',{}).get('displayName','?')}",
         f"  Version: {pr.get('version')} | Open tasks: {pr.get('openTaskCount', 0)}",
     ]
     reviewers = pr.get("reviewers") or []
     if reviewers:
         rs = ", ".join(
-            f"{r.get('user',{}).get('name','?')}({'✓' if r.get('approved') else '·'})"
+            f"{r.get('user',{}).get('name','?')}({'[x]' if r.get('approved') else '[ ]'})"
             for r in reviewers
         )
         lines.append(f"  Reviewers: {rs}")
@@ -190,7 +195,7 @@ def _act_status(client: BitbucketDataCenterClient | None, err: str, svc) -> str:
         version = props.get("version", "?")
         out.append(f"  Server : OK (version {version})")
     except BitbucketError as exc:
-        out.append(f"  Server : FAIL — {exc}")
+        out.append(f"  Server : FAIL -- {exc}")
     return "\n".join(out)
 
 
@@ -214,7 +219,7 @@ def _act_list_projects(client: BitbucketDataCenterClient, kwargs: dict) -> str:
     for p in projects[:50]:
         lines.append(f"  {p.get('key','?'):16} {p.get('name','?')}")
     if len(projects) > 50:
-        lines.append(f"  … +{len(projects) - 50} more")
+        lines.append(f"  ... +{len(projects) - 50} more")
     return "\n".join(lines)
 
 
@@ -222,11 +227,11 @@ def _act_list_repos(client: BitbucketDataCenterClient, project: str) -> str:
     repos = client.list_repos(project)
     if not repos:
         return f"[bitbucket:repos] {project}: (none)"
-    lines = [f"[bitbucket:repos] {project} — {len(repos)} repo(s)"]
+    lines = [f"[bitbucket:repos] {project} - {len(repos)} repo(s)"]
     for r in repos[:80]:
         lines.append(f"  {r.get('slug','?'):30} {r.get('name','?')}")
     if len(repos) > 80:
-        lines.append(f"  … +{len(repos) - 80} more")
+        lines.append(f"  ... +{len(repos) - 80} more")
     return "\n".join(lines)
 
 
@@ -252,7 +257,7 @@ def _act_list_prs(client, project: str, repo: str, kwargs: dict) -> str:
     )
     if not prs:
         return f"[bitbucket:prs] {project}/{repo} state={state}: (none)"
-    out = [f"[bitbucket:prs] {project}/{repo} state={state} — {len(prs)} PR(s)"]
+    out = [f"[bitbucket:prs] {project}/{repo} state={state} - {len(prs)} PR(s)"]
     for pr in prs:
         out.append(_format_pr(pr))
     return "\n".join(out)
@@ -266,7 +271,7 @@ def _act_get_pr(client, project: str, repo: str, pr_id: int) -> str:
 def _act_get_pr_diff(client, project: str, repo: str, pr_id: int, kwargs: dict) -> str:
     diff = client.get_pr_diff(project, repo, pr_id, context_lines=int(kwargs.get("context_lines", 3)))
     if len(diff) > _DIFF_PREVIEW_CHARS:
-        diff = diff[:_DIFF_PREVIEW_CHARS] + "\n… [diff truncated]"
+        diff = diff[:_DIFF_PREVIEW_CHARS] + "\n... [diff truncated]"
     return f"[bitbucket:diff] {project}/{repo}#{pr_id}\n{diff}"
 
 
@@ -274,7 +279,7 @@ def _act_get_pr_activities(client, project: str, repo: str, pr_id: int) -> str:
     acts = client.get_pr_activities(project, repo, pr_id)
     if not acts:
         return f"[bitbucket:pr-activity] {project}/{repo}#{pr_id}: (none)"
-    out = [f"[bitbucket:pr-activity] {project}/{repo}#{pr_id} — {len(acts)} event(s)"]
+    out = [f"[bitbucket:pr-activity] {project}/{repo}#{pr_id} - {len(acts)} event(s)"]
     for a in acts[:50]:
         out.append(_format_activity(a))
     return "\n".join(out)
@@ -341,11 +346,11 @@ def _act_list_branches(client, project: str, repo: str, kwargs: dict) -> str:
     branches = client.list_branches(project, repo, filter_text=kwargs.get("filter", ""))
     if not branches:
         return f"[bitbucket:branches] {project}/{repo}: (none)"
-    out = [f"[bitbucket:branches] {project}/{repo} — {len(branches)} branch(es)"]
+    out = [f"[bitbucket:branches] {project}/{repo} - {len(branches)} branch(es)"]
     for b in branches[:80]:
         out.append(_format_branch(b))
     if len(branches) > 80:
-        out.append(f"  … +{len(branches) - 80} more")
+        out.append(f"  ... +{len(branches) - 80} more")
     return "\n".join(out)
 
 
@@ -378,7 +383,7 @@ def _act_list_commits(client, project: str, repo: str, kwargs: dict) -> str:
     )
     if not commits:
         return f"[bitbucket:commits] {project}/{repo}: (none)"
-    out = [f"[bitbucket:commits] {project}/{repo} — {len(commits)} commit(s)"]
+    out = [f"[bitbucket:commits] {project}/{repo} - {len(commits)} commit(s)"]
     for c in commits:
         out.append(_format_commit(c))
     return "\n".join(out)
@@ -388,7 +393,7 @@ def _act_list_activity(client, project: str, repo: str, kwargs: dict) -> str:
     acts = client.list_repo_activities(project, repo, limit=int(kwargs.get("limit", 30)))
     if not acts:
         return f"[bitbucket:activity] {project}/{repo}: (none)"
-    out = [f"[bitbucket:activity] {project}/{repo} — {len(acts)} event(s)"]
+    out = [f"[bitbucket:activity] {project}/{repo} - {len(acts)} event(s)"]
     for a in acts:
         out.append(_format_commit(a))
     return "\n".join(out)
@@ -401,7 +406,7 @@ def _act_build_status(client, kwargs: dict) -> str:
     builds = client.get_build_status(commit)
     if not builds:
         return f"[bitbucket:build_status] {commit[:12]}: (none)"
-    out = [f"[bitbucket:build_status] {commit[:12]} — {len(builds)} build(s)"]
+    out = [f"[bitbucket:build_status] {commit[:12]} - {len(builds)} build(s)"]
     for b in builds:
         out.append(_format_build(b))
     return "\n".join(out)
@@ -429,10 +434,10 @@ def _act_list_webhooks(client, project: str, repo: str) -> str:
     hooks = client.list_webhooks(project, repo)
     if not hooks:
         return f"[bitbucket:webhooks] {project}/{repo}: (none)"
-    out = [f"[bitbucket:webhooks] {project}/{repo} — {len(hooks)} hook(s)"]
+    out = [f"[bitbucket:webhooks] {project}/{repo} - {len(hooks)} hook(s)"]
     for h in hooks:
         out.append(
-            f"  #{h.get('id')} [{'on' if h.get('active') else 'off'}] {h.get('name','?')} → {h.get('url','?')}"
+            f"  #{h.get('id')} [{'on' if h.get('active') else 'off'}] {h.get('name','?')} -> {h.get('url','?')}"
         )
         evs = h.get("events") or []
         if evs:
@@ -454,7 +459,7 @@ def _act_create_webhook(client, project: str, repo: str, kwargs: dict) -> str:
         active=bool(kwargs.get("active", True)),
         secret=kwargs.get("secret", ""),
     )
-    return f"[bitbucket:webhook-created] {project}/{repo} #{res.get('id','?')} {name} → {url}"
+    return f"[bitbucket:webhook-created] {project}/{repo} #{res.get('id','?')} {name} -> {url}"
 
 
 def _act_delete_webhook(client, project: str, repo: str, kwargs: dict) -> str:

{code_context_control-2.39.0 → code_context_control-2.40.0}/cli/tools/delegate.py

@@ -11,10 +11,12 @@ import os
 import shutil
 import subprocess
 import sys
+import threading
 import time
 from pathlib import Path
 
 from core import count_tokens
+from services.circuit_breaker import CircuitBreaker
 
 log = logging.getLogger(__name__)
 
@@ -252,11 +254,20 @@ def _handle_claude_delegate(task: str, task_type: str, context: str,
                              file_path: str, svc, dcfg: dict, finalize) -> str:
     """Handle delegation via Claude Code CLI."""
     timeout = int(dcfg.get("claude_timeout", 90))
+    breaker = _backend_breaker("claude", dcfg)
+    if not breaker.allow():
+        return finalize("c3_delegate", {"task_type": task_type, "backend": "claude"},
+                        "[delegate:degraded] Claude skipped after repeated failures; retrying in "
+                        f"~{breaker.cooldown_remaining()}s. Run 'claude --version' to diagnose.",
+                        "degraded")
     _log_progress(svc, f"[delegate] Routing {task_type} → Claude CLI...")
     output, ok = _run_claude(task, context, cwd=str(svc.project_path), timeout=timeout)
     if not ok:
+        if breaker.record_failure():
+            _notify_backend_degraded(svc, "claude", breaker)
         return finalize("c3_delegate", {"task_type": task_type, "backend": "claude"},
                         output, "error")
+    breaker.record_success()
     return finalize("c3_delegate", {"task_type": task_type, "backend": "claude"},
                     output, "ok")
 
@@ -681,6 +692,51 @@ DELEGATE_TASKS = {
 _delegate_cache: dict[str, tuple[str, int]] = {}
 _delegate_metrics = {"total_calls": 0, "tokens_saved": 0}
 
+# Per-backend runtime circuit breakers. Distinct from the install-status flags
+# (_gemini_available etc., which only answer "is the CLI on PATH"): these track
+# *runtime* health so a broken-but-installed backend (expired auth, repeated
+# timeouts) stops re-spawning a 90-120s subprocess on every call. Keyed by
+# backend name and intentionally process-global — backend health (auth, CLI
+# version) is a property of the host, not of any single project.
+_backend_breakers: dict[str, CircuitBreaker] = {}
+_backend_breakers_lock = threading.Lock()
+
+
+def _backend_breaker(name: str, dcfg: dict | None = None) -> CircuitBreaker:
+    """Return (creating on first use) the runtime circuit breaker for a backend."""
+    with _backend_breakers_lock:
+        breaker = _backend_breakers.get(name)
+        if breaker is None:
+            cfg = dcfg or {}
+            breaker = CircuitBreaker(
+                name,
+                failure_threshold=int(cfg.get("breaker_failure_threshold", 3) or 3),
+                cooldown_seconds=float(cfg.get("breaker_cooldown_seconds", 60) or 60),
+            )
+            _backend_breakers[name] = breaker
+        return breaker
+
+
+def _notify_backend_degraded(svc, name: str, breaker: CircuitBreaker) -> None:
+    """Surface a backend trip via the NotificationStore (best-effort, never raises)."""
+    notifications = getattr(svc, "notifications", None)
+    if notifications is None:
+        return
+    try:
+        notifications.add(
+            agent="c3",
+            severity="warning",
+            title=f"Delegate backend degraded: {name}",
+            message=(
+                f"{name} failed {breaker.failure_threshold}x consecutively; c3_delegate "
+                f"will skip it for ~{int(breaker.cooldown_seconds)}s instead of re-spawning "
+                f"the CLI. Run '{name} --version' to diagnose."
+            ),
+            replace_if_unacked=True,
+        )
+    except Exception:
+        pass
+
 
 def get_delegate_metrics() -> dict:
     return dict(_delegate_metrics)
@@ -765,6 +821,13 @@ def _handle_codex_delegate(task: str, task_type: str, context: str,
                         "[delegate:error] Codex CLI not available. Run 'codex --version' to diagnose.",
                         "unavailable")
 
+    breaker = _backend_breaker("codex", dcfg)
+    if not breaker.allow():
+        return finalize("c3_delegate", {"task_type": task_type, "backend": "codex"},
+                        "[delegate:degraded] Codex skipped after repeated failures; retrying in "
+                        f"~{breaker.cooldown_remaining()}s. Run 'codex --version' to diagnose.",
+                        "degraded")
+
     # Resolve model/sandbox/reasoning from config or defaults
     cdef = CODEX_MODELS.get(task_type, CODEX_MODELS.get("ask", {}))
     model = dcfg.get("codex_default_model") or cdef.get("model", "gpt-5.3-codex-spark")
@@ -807,10 +870,13 @@ def _handle_codex_delegate(task: str, task_type: str, context: str,
     elapsed = round(time.monotonic() - t0, 1)
 
     if not ok:
+        if breaker.record_failure():
+            _notify_backend_degraded(svc, "codex", breaker)
         return finalize("c3_delegate",
                         {"task_type": task_type, "backend": "codex", "model": model, "elapsed": f"{elapsed}s"},
                         output, "error")
 
+    breaker.record_success()
     _delegate_metrics["total_calls"] += 1
     _delegate_cache[ckey] = (output, count_tokens(output))
 
@@ -880,6 +946,13 @@ def _handle_gemini_delegate(task: str, task_type: str, context: str,
                         "[delegate:error] Gemini CLI not available. Run 'gemini --version' to diagnose.",
                         "unavailable")
 
+    breaker = _backend_breaker("gemini", dcfg)
+    if not breaker.allow():
+        return finalize("c3_delegate", {"task_type": task_type, "backend": "gemini"},
+                        "[delegate:degraded] Gemini skipped after repeated failures; retrying in "
+                        f"~{breaker.cooldown_remaining()}s. Run 'gemini --version' to diagnose.",
+                        "degraded")
+
     # Resolve model from config or defaults
     gdef = GEMINI_MODELS.get(task_type, GEMINI_MODELS.get("ask", {}))
     model = dcfg.get("gemini_default_model") or gdef.get("model", "gemini-2.5-flash")
@@ -919,10 +992,13 @@ def _handle_gemini_delegate(task: str, task_type: str, context: str,
     elapsed = round(time.monotonic() - t0, 1)
 
     if not ok:
+        if breaker.record_failure():
+            _notify_backend_degraded(svc, "gemini", breaker)
         return finalize("c3_delegate",
                         {"task_type": task_type, "backend": "gemini", "model": model, "elapsed": f"{elapsed}s"},
                         output, "error")
 
+    breaker.record_success()
     _delegate_metrics["total_calls"] += 1
     _delegate_cache[ckey] = (output, count_tokens(output))
 
@@ -1068,9 +1144,11 @@ def handle_delegate(task: str, task_type: str, context: str, file_path: str,
         _gemini_avail = (_gemini_available is True) or (
             _gemini_available is None and task_type not in _light_tasks and _is_gemini_on_path()
         )
-        if task_type in heavy_codex and _codex_avail and _codex_available is not False:
+        if (task_type in heavy_codex and _codex_avail and _codex_available is not False
+                and _backend_breaker("codex", dcfg).allow()):
             backend = "codex"
-        elif task_type in heavy_gemini and _gemini_avail and _gemini_available is not False:
+        elif (task_type in heavy_gemini and _gemini_avail and _gemini_available is not False
+                and _backend_breaker("gemini", dcfg).allow()):
             backend = "gemini"
         else:
             backend = "ollama"

{code_context_control-2.39.0 → code_context_control-2.40.0/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.39.0
+Version: 2.40.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -283,9 +283,12 @@ Access Token. Tokens live in the **OS keyring** (Windows Credential Manager,
 macOS Keychain, Linux Secret Service) — never in `.c3/config.json`.
 
 ```bash
-# One-time login per server
+# One-time login per server (stored under this project's .c3/config.json)
 c3 bitbucket login --url https://bitbucket.example.com
-#  → prompts for username + PAT (masked)
+#  -> prompts for username + PAT (masked)
+
+# ...or store it globally so every C3 project can use it
+c3 bitbucket login --global --url https://bitbucket.example.com
 
 # Pin defaults so subsequent calls don't need project/repo
 c3 bitbucket set-default --project PROJ --repo my-service
@@ -294,6 +297,16 @@ c3 bitbucket set-default --project PROJ --repo my-service
 c3 bitbucket status
 ```
 
+**Account resolution precedence:** the project's `.c3/config.json` wins, but when
+it has no active account C3 falls back to the global `~/.c3/config.json`. So a
+single `login --global` (or any login done from your home directory) is reusable
+across every C3 project — the PAT always lives in the OS keyring, never on disk.
+
+> **Upgrading:** stop the running `c3-mcp` server / CLI before `c3 upgrade`. A live
+> process can hold package files open, leaving pip's `~`-prefixed backup dirs
+> (`~ervices`, `~ools`, …) in `site-packages`; those are inert and safe to delete
+> after the upgrade completes.
+
 The MCP tool dispatches by `action`. Read-only actions: `status`, `whoami`,
 `list_projects`, `list_repos`, `get_repo`, `list_prs`, `get_pr`, `get_pr_diff`,
 `get_pr_activities`, `list_branches`, `list_commits`, `list_activity`,

{code_context_control-2.39.0 → code_context_control-2.40.0}/code_context_control.egg-info/SOURCES.txt

@@ -108,6 +108,7 @@ services/auto_memory.py
 services/benchmark_dashboard.py
 services/bitbucket_client.py
 services/bitbucket_credentials.py
+services/circuit_breaker.py
 services/claude_md.py
 services/compressor.py
 services/context_snapshot.py
@@ -158,9 +159,11 @@ tests/test_activity_reporter.py
 tests/test_aider_polyglot.py
 tests/test_bitbucket_cli_smoke.py
 tests/test_bitbucket_client.py
+tests/test_bitbucket_config_fallback.py
 tests/test_bitbucket_credentials.py
 tests/test_bitbucket_tool.py
 tests/test_c3_shell.py
+tests/test_circuit_breaker.py
 tests/test_claude_md_merge.py
 tests/test_cli_smoke.py
 tests/test_e2e_benchmark.py

{code_context_control-2.39.0 → code_context_control-2.40.0}/core/config.py

@@ -290,15 +290,41 @@ BITBUCKET_DEFAULTS = {
 }
 
 
+def _read_bitbucket_section(config_file: Path) -> dict:
+    """Return the ``bitbucket`` section of a config file, or ``{}``."""
+    if not config_file.exists():
+        return {}
+    try:
+        with open(config_file, encoding="utf-8") as f:
+            data = json.load(f)
+    except Exception:
+        return {}
+    section = data.get("bitbucket", {})
+    return section if isinstance(section, dict) else {}
+
+
 def load_bitbucket_config(project_path: str) -> dict:
-    """Load Bitbucket config from .c3/config.json, merged with defaults."""
-    config_file = Path(project_path) / ".c3" / "config.json"
-    overrides = {}
-    if config_file.exists():
+    """Load Bitbucket config from .c3/config.json, merged with defaults.
+
+    Resolution precedence: the project ``<project>/.c3/config.json`` wins, but
+    when it has no active account we fall back to the global
+    ``~/.c3/config.json`` so a one-time ``c3 bitbucket login`` (or
+    ``login --global``) is reusable across every C3 project. The PAT itself
+    always lives in the OS keyring, never in these files.
+    """
+    project_file = Path(project_path) / ".c3" / "config.json"
+    overrides = _read_bitbucket_section(project_file)
+    if not (overrides.get("active") or {}).get("base_url"):
+        # Path.home() raises RuntimeError when no home dir is resolvable (e.g.
+        # a stripped subprocess env); treat that as "no global fallback".
         try:
-            with open(config_file, encoding="utf-8") as f:
-                data = json.load(f)
-            overrides = data.get("bitbucket", {})
+            home_file = Path.home() / ".c3" / "config.json"
+            already_home = home_file.resolve() == project_file.resolve()
         except Exception:
-            pass
+            home_file = None
+            already_home = True
+        if home_file is not None and not already_home:
+            home_overrides = _read_bitbucket_section(home_file)
+            if (home_overrides.get("active") or {}).get("base_url"):
+                overrides = home_overrides
     return {**BITBUCKET_DEFAULTS, **overrides}

{code_context_control-2.39.0 → code_context_control-2.40.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.39.0"
+version = "2.40.0"
 description = "Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer."
 readme = "README.md"
 requires-python = ">=3.10"