code-context-control 2.82.0__tar.gz → 2.86.0__tar.gz

{code_context_control-2.82.0/code_context_control.egg-info → code_context_control-2.86.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.82.0
+Version: 2.86.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
@@ -178,7 +178,7 @@ Twelve tabs. The dashboard above shows token savings, indexed files, the live se
   <img src="https://raw.githubusercontent.com/drknowhow/code-context-control/main/docs/screenshots/2026-07/ui_tasks.png" alt="C3 Tasks" width="900">
 </p>
 
-**Tasks** (v2.45.0, extended v2.53.0) is a durable per-project tracker — dependencies and subtasks, milestones, decision notes, full event history, health reports, and both automatic and manual time tracking. It rolls up into the Hub's cross-project board.
+**Tasks** (v2.45.0, extended v2.53.0) is a durable per-project tracker — dependencies and subtasks, milestones, decision notes, full event history, health reports, and both automatic and manual time tracking. It rolls up into the Hub's cross-project board. Shipped milestones can be **completed** (v2.86.0) — they leave the board while their tasks keep the milestone link, unlike archiving, which detaches them.
 
 **Instructions** keeps your agent-facing docs in sync. C3-generated content sits inside a `<!-- C3:BEGIN … -->` block; anything you write outside it is preserved. Since v2.60.0 generated docs point at `.c3/MAP.md` — a machine-owned, byte-stable repo map C3 refreshes automatically — instead of embedding a tree that goes stale. `AGENTS.md` serves both Codex and Antigravity; `GEMINI.md` is read if present but no longer generated (the Gemini CLI profile was removed in v2.52).
 
@@ -243,6 +243,7 @@ c3 access mask activate                         # purge pre-mask artifacts, buil
 - **`deny` means deny-enumerate too** — denied paths never appear in search results, maps, or the vector index.
 - **Masked means read-only, always.** Cropped rows have no inverse, so an edit in transformed coordinates would corrupt the one file you protected.
 - **Four deterministic presets, no LLM in the read path:** `redact_secrets`, `redact_columns` (salted one-way pseudonyms — joins survive, no reverse dictionary), `sample_rows`, `signatures_only`.
+- **Sensible defaults out of the box** (v2.86.0). A fresh install seeds `*.pem`, `id_rsa*`, and `*.key` as deny rules in global scope — visible in `c3 access list` and removable like any rule you wrote yourself. Delete one and it stays deleted.
 - **Rule changes are human-only** (UI tab or CLI) and ledger-logged. Agents have no mutation surface.
 - **Built-ins can be switched off when you need to** (v2.65.0). `**/.env*`, `**/.c3/**`, `**/.claude/settings*.json` and `**/.git/**` yield to `c3 access builtin disable <glob>`, which makes you retype the glob first. It takes **two keys** — a config entry *and* a keyring attestation — so an agent that manages to write `config.json` still cannot grant itself write access to your settings. The credential vault stays absolute.
 - **Honest coverage.** This guards *cooperative* agents against mistakes and prompt injection. It is not a sandbox — a raw shell outside C3's tools still sees the real bytes.

{code_context_control-2.82.0 → code_context_control-2.86.0}/README.md

@@ -115,7 +115,7 @@ Twelve tabs. The dashboard above shows token savings, indexed files, the live se
   <img src="https://raw.githubusercontent.com/drknowhow/code-context-control/main/docs/screenshots/2026-07/ui_tasks.png" alt="C3 Tasks" width="900">
 </p>
 
-**Tasks** (v2.45.0, extended v2.53.0) is a durable per-project tracker — dependencies and subtasks, milestones, decision notes, full event history, health reports, and both automatic and manual time tracking. It rolls up into the Hub's cross-project board.
+**Tasks** (v2.45.0, extended v2.53.0) is a durable per-project tracker — dependencies and subtasks, milestones, decision notes, full event history, health reports, and both automatic and manual time tracking. It rolls up into the Hub's cross-project board. Shipped milestones can be **completed** (v2.86.0) — they leave the board while their tasks keep the milestone link, unlike archiving, which detaches them.
 
 **Instructions** keeps your agent-facing docs in sync. C3-generated content sits inside a `<!-- C3:BEGIN … -->` block; anything you write outside it is preserved. Since v2.60.0 generated docs point at `.c3/MAP.md` — a machine-owned, byte-stable repo map C3 refreshes automatically — instead of embedding a tree that goes stale. `AGENTS.md` serves both Codex and Antigravity; `GEMINI.md` is read if present but no longer generated (the Gemini CLI profile was removed in v2.52).
 
@@ -180,6 +180,7 @@ c3 access mask activate                         # purge pre-mask artifacts, buil
 - **`deny` means deny-enumerate too** — denied paths never appear in search results, maps, or the vector index.
 - **Masked means read-only, always.** Cropped rows have no inverse, so an edit in transformed coordinates would corrupt the one file you protected.
 - **Four deterministic presets, no LLM in the read path:** `redact_secrets`, `redact_columns` (salted one-way pseudonyms — joins survive, no reverse dictionary), `sample_rows`, `signatures_only`.
+- **Sensible defaults out of the box** (v2.86.0). A fresh install seeds `*.pem`, `id_rsa*`, and `*.key` as deny rules in global scope — visible in `c3 access list` and removable like any rule you wrote yourself. Delete one and it stays deleted.
 - **Rule changes are human-only** (UI tab or CLI) and ledger-logged. Agents have no mutation surface.
 - **Built-ins can be switched off when you need to** (v2.65.0). `**/.env*`, `**/.c3/**`, `**/.claude/settings*.json` and `**/.git/**` yield to `c3 access builtin disable <glob>`, which makes you retype the glob first. It takes **two keys** — a config entry *and* a keyring attestation — so an agent that manages to write `config.json` still cannot grant itself write access to your settings. The credential vault stays absolute.
 - **Honest coverage.** This guards *cooperative* agents against mistakes and prompt injection. It is not a sandbox — a raw shell outside C3's tools still sees the real bytes.

{code_context_control-2.82.0 → code_context_control-2.86.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.82.0"
+__version__ = "2.86.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):
@@ -5535,6 +5535,14 @@ def cmd_install_mcp(args):
     except Exception as e:
         print(f"Warning: Could not update global CLAUDE.md: {e}")
 
+    # ── Default Access Guard rules (first run only) ─────────────
+    from services import access_guard
+    seeded = access_guard.seed_default_global_rules()
+    if seeded.get("seeded"):
+        rules = ", ".join(seeded["rules"])
+        print(f"Seeded default Access Guard deny rules into global scope: {rules}")
+        print("  (remove with: c3 access remove <glob> --kind deny --global)")
+
     # ── Install /terse skill for supported IDEs ──────────────────
     if profile.name in ("claude-code", "codex"):
         try:
@@ -6055,6 +6063,15 @@ def _ci_main(args) -> int:
     from cli.tools.ci import handle_ci
 
     sub = getattr(args, "ci_cmd", None) or "inspect"
+    if sub == "publish":
+        if getattr(args, "dry_run", False):
+            args.job = "dry-run"
+        if getattr(args, "force", False):
+            args.allow_side_effects = True
+    if sub == "cache" and getattr(args, "clear", False):
+        # `--clear` is a flag on the CLI; the shared handler takes it
+        # positionally so both surfaces route through one code path.
+        args.job = "clear"
     project_path = getattr(args, "project_path", ".") or "."
     as_json = bool(getattr(args, "json", False))
 
@@ -6106,7 +6123,11 @@ def _ci_main(args) -> int:
         getattr(args, "event", "") or "",
         getattr(args, "engine", "auto") or "auto",
         bool(getattr(args, "allow_side_effects", False)),
-        getattr(args, "network", "") or "")
+        getattr(args, "network", "") or "",
+        "required" if getattr(args, "required", False) else "full",
+        getattr(args, "base", "") or "",
+        bool(getattr(args, "allow_host_mutation", False)),
+        bool(getattr(args, "no_cache", False)))
     print(out)
     # Exit code is the finding: a non-full verdict must not read as success to
     # a shell script or a pre-push hook.
@@ -6590,6 +6611,16 @@ def _override_audit(grant: dict, project_path: str) -> None:
 
 def cmd_access(args):
     """Access Guard rule management — human-only mutation surface (spec §1)."""
+    from services import access_guard
+
+    # First `c3 access` touch seeds the removable defaults (spec §1). A
+    # no-op forever after: any existing access section, even an emptied
+    # one, means the user has taken over the scope.
+    seeded = access_guard.seed_default_global_rules()
+    if seeded.get("seeded"):
+        print(f"[seeded] default global deny rules: {', '.join(seeded['rules'])}")
+        print("  Remove any of them: c3 access remove <glob> --kind deny --global\n")
+
     sub = getattr(args, "access_cmd", None)
     if not sub:
         print("Usage: c3 access {list,add,remove,check,stats,mask,builtin} [args]")

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/commands/parser.py

@@ -507,6 +507,17 @@ def build_parser(version: str, parse_cli_ide_arg):
     ci_run.add_argument("--allow-side-effects", action="store_true",
                         help="Let the act engine run jobs that look like they "
                              "publish or deploy. Refused by default.")
+    ci_run.add_argument("--required", action="store_true",
+                        help="Run only the jobs a change could have broken "
+                             "(conservative; see `c3 ci plan`)")
+    ci_run.add_argument("--base", default="",
+                        help="Diff against this ref instead of the working tree")
+    ci_run.add_argument("--allow-host-mutation", action="store_true",
+                        help="Permit native steps that reconfigure this machine "
+                             "(pip/npm -g/apt install). Refused by default.")
+    ci_run.add_argument("--no-cache", action="store_true",
+                        help="Ignore cached results and execute every "
+                             "selected job")
     ci_run.add_argument("--network", default="",
                         help="Container network for the act engine (e.g. `none` "
                              "to cut egress). Default: act's own.")
@@ -530,6 +541,22 @@ def build_parser(version: str, parse_cli_ide_arg):
     ci_logs.add_argument("--tail", type=int, default=200)
 
     _ci_common(ci_subs.add_parser("runs", help="Recent local CI runs"))
+    ci_plan = _ci_common(ci_subs.add_parser(
+        "plan", help="Show which jobs a change requires, and why"))
+    ci_plan.add_argument("--base", default="",
+                         help="Diff against this ref instead of the working tree")
+    ci_pub = _ci_common(ci_subs.add_parser(
+        "publish", help="Post the last run as a GitHub commit status"))
+    ci_pub.add_argument("--run", dest="run_id", default="")
+    ci_pub.add_argument("--dry-run", action="store_true")
+    ci_pub.add_argument("--force", action="store_true",
+                        help="Publish a PARTIAL result as `pending`")
+    _ci_common(ci_subs.add_parser(
+        "history", help="Per-job pass/fail history and flake detection"))
+    ci_cache_p = _ci_common(ci_subs.add_parser(
+        "cache", help="Cached-result store: size, or --clear it"))
+    ci_cache_p.add_argument("--clear", action="store_true",
+                            help="Drop every cached result and dependency cache")
     _ci_common(ci_subs.add_parser(
         "doctor", help="Which execution engines are available on this machine"))
 

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/hook_access_guard.py

@@ -41,7 +41,24 @@ _MAX_TOKENS = 200
 # "NTFS alternate data stream". The ADS check stays strict for real path
 # arguments (_WRITE_TOOLS/_READ_TOOLS); here it only produced false denies on
 # commit messages, curl, and gh (#50).
-_SCHEME_RE = re.compile(r"^[a-z][a-z0-9+.\-]*://", re.IGNORECASE)
+#
+# UNANCHORED, and that is the fix rather than an oversight. `^…://` only ever
+# recognised a token that BEGINS with a scheme, which is the same
+# whitelist-a-shape mistake #50 made and this module's own header calls out —
+# and the `_SYNTAX_CHARS` generalisation does not cover the gap, because a
+# token can carry a URL and no syntax at all. Observed 2026-08-11: the single
+# argument of
+#     printf '\n---\n\nhttps://claude.ai/code/session_01Hs28…\n' >> body.md
+# strips to `\n---\n\nhttps://claude.ai/…`, which has a separator (`\` and
+# `/`), no syntax characters, no `::`, and no leading scheme. It reached
+# ag.check, canonicalised to a residual colon, and hard-denied a command whose
+# only file argument was an ordinary markdown path. Third logged instance of
+# this class in five days (two on 2026-08-07 were Windows paths inside Python
+# string literals).
+#
+# A token containing `://` anywhere is a network literal, not an NTFS stream:
+# a real stream is `file:name:$TYPE`, and no spelling of it contains `//`.
+_SCHEME_RE = re.compile(r"[a-z][a-z0-9+.\-]*://", re.IGNORECASE)
 # IPv6 literal or CIDR: >=2 colons, hex groups only, optional [] and /prefix.
 # 'C:/x/f.txt:stream' has one colon and non-hex parts, so it never matches.
 _IPV6_RE = re.compile(
@@ -104,8 +121,13 @@ _CD_RE = re.compile(
 
 
 def _is_network_token(tok: str) -> bool:
-    """True for URLs and IPv6 literals/CIDRs — never for an ADS spelling."""
-    return bool(_SCHEME_RE.match(tok) or _IPV6_RE.match(tok))
+    """True for URLs and IPv6 literals/CIDRs — never for an ADS spelling.
+
+    ``search`` for the scheme (a URL anywhere in the token disqualifies it as
+    a path), ``match`` for IPv6 — that pattern is a whole-token shape and
+    anchoring is what keeps `C:/x/f.txt:stream` from matching it.
+    """
+    return bool(_SCHEME_RE.search(tok) or _IPV6_RE.match(tok))
 
 
 def _is_scope_token(tok: str) -> bool:

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/hub_server.py

@@ -2740,6 +2740,20 @@ def api_pm_milestone():
         return jsonify({"error": "id is required"}), 400
 
     if request.method == "PUT":
+        # {complete: true} / {reopen: true} switch lifecycle; tasks keep
+        # their milestone link (unlike DELETE = archive + detach).
+        if data.get("complete"):
+            res = store.complete_milestone(ms_id)
+            if "error" in res:
+                return jsonify(res), 400
+            _pm_audit(resolved, "milestone", "complete", res["id"])
+            return jsonify({"completed": True, "milestone": res})
+        if data.get("reopen"):
+            res = store.reopen_milestone(ms_id)
+            if "error" in res:
+                return jsonify(res), 400
+            _pm_audit(resolved, "milestone", "reopen", res["id"])
+            return jsonify({"reopened": True, "milestone": res})
         res = store.update_milestone(ms_id, expected_rev=data.get("expected_rev"),
                                      **(data.get("fields") or {}))
         if "error" in res:

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/mcp_server.py

@@ -771,10 +771,25 @@ async def c3_ci(action: str = "inspect", job: str = "", run_id: str = "",
                 allow_foreign: bool = False, workflow: str = "",
                 tail: int = 200, timeout: int = 0, event: str = "",
                 engine: str = "auto", allow_side_effects: bool = False,
-                network: str = "", ctx: Context = None) -> str:
+                network: str = "", mode: str = "full", base: str = "",
+                allow_host_mutation: bool = False,
+                no_cache: bool = False, ctx: Context = None) -> str:
     """RUN THIS REPO'S REAL CI LOCALLY — before pushing, not after.
     Reads .github/workflows/*.yml as the source of truth (no second CI config).
-    actions: inspect | run | rerun | status | failures | logs | runs | doctor.
+    actions: inspect | plan | run | rerun | status | failures | logs | runs |
+      cache | history | publish | doctor. publish posts the last run as a
+      GitHub COMMIT STATUS via your gh auth; it refuses a dirty tree, an
+      unpushed commit, and (unless forced) a PARTIAL result. history reports per-job fail rates and
+      flags FLAKY jobs — ones that both passed and failed on identical
+      inputs, so the code cannot be the cause. A job whose inputs are unchanged since it last passed
+      is reused (status `cached`, nothing executed); no_cache forces it.
+    mode: full (default) | required. required runs only the jobs a change
+      could have broken; it is CONSERVATIVE — anything unmapped runs. Use
+      action='plan' to see the decision and reason for every job first.
+    allow_host_mutation: the NATIVE engine refuses steps that would
+      reconfigure this machine (pip/npm -g/apt/brew install...). It has no
+      isolation; running this repo's own CI natively once uninstalled C3.
+      Prefer engine='act'.
     inspect: workflows, the job DAG, and which jobs are runnable on THIS host.
     run: execute in dependency order; job='lint' or 'test (ubuntu-latest, 3.12)'
       selects one (bare job name = all its matrix cells). A job whose dependency
@@ -798,7 +813,9 @@ async def c3_ci(action: str = "inspect", job: str = "", run_id: str = "",
     return await asyncio.to_thread(handle_ci, action, job, run_id,
                                    allow_foreign, workflow, tail, timeout,
                                    svc, finalize, event, engine,
-                                   allow_side_effects, network)
+                                   allow_side_effects, network,
+                                   mode, base, allow_host_mutation,
+                                   no_cache)
 
 
 @mcp.tool()
@@ -1088,7 +1105,9 @@ async def c3_task(
     Time: time_add (minutes 1-1440 [+note/due_date=date/task_id]), time_update / time_delete (ref=entry id),
       time_list (manual entries + recent auto sessions), time_summary (today/7d/30d, auto vs manual).
       Auto-tracking: server startup + tool calls ping .c3/time; idle gaps >15min close a session.
-    Milestones: milestone_add (name [+target_date]), milestone_update, milestone_list (with progress %), milestone_archive.
+    Milestones: milestone_add (name [+target_date]), milestone_update, milestone_list (with progress %),
+      milestone_complete (close a shipped milestone; refuses while open tasks remain; tasks KEEP their link),
+      milestone_reopen (undo complete), milestone_archive (removal: detaches tasks).
     Notes: note_add (note [+kind=decision] [+task_id]), note_list.
     History: history ([+task_id] [+limit]) — append-only event log (who/what/when, before->after), newest first.
     task_id accepts any unique id prefix (>=4 chars); milestone accepts id or unique name.

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/server.py

@@ -1295,6 +1295,20 @@ def api_pm_milestone():
     if not ms_id:
         return jsonify({"error": "id is required"}), 400
     if request.method == "PUT":
+        # {complete: true} / {reopen: true} switch lifecycle; tasks keep
+        # their milestone link (unlike DELETE = archive + detach).
+        if data.get("complete"):
+            res = store.complete_milestone(ms_id)
+            if "error" in res:
+                return jsonify(res), 400
+            _pm_audit("milestone", "complete", res["id"])
+            return jsonify({"completed": True, "milestone": res})
+        if data.get("reopen"):
+            res = store.reopen_milestone(ms_id)
+            if "error" in res:
+                return jsonify(res), 400
+            _pm_audit("milestone", "reopen", res["id"])
+            return jsonify({"reopened": True, "milestone": res})
         res = store.update_milestone(ms_id, expected_rev=data.get("expected_rev"),
                                      **(data.get("fields") or {}))
         if "error" in res:

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/tools/ci.py

@@ -12,13 +12,14 @@ That distinction is the product.
 """
 from __future__ import annotations
 
+from services import ci_impact
 from services import ci_runner as cr
 from services.ci_workflow import inspect_project
 
 _MARK = {
     cr.PASSED: "PASS", cr.FAILED: "FAIL", cr.SKIPPED: "SKIP",
     cr.UNSUPPORTED: "UNSUP", cr.FOREIGN: "OTHER-OS", cr.TIMEOUT: "TIMEOUT",
-    cr.DESELECTED: "-",
+    cr.DESELECTED: "-", cr.CACHED: "CACHED",
 }
 
 # Verdicts an agent may treat as "safe to push". Deliberately one item long.
@@ -81,7 +82,10 @@ def _failure_rows(jobs: list, limit: int = 25) -> list:
 def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
               workflow: str, tail: int, timeout: int, svc, finalize,
               event: str = "", engine: str = "auto",
-              allow_side_effects: bool = False, network: str = "") -> str:
+              allow_side_effects: bool = False, network: str = "",
+              mode: str = "full", base: str = "",
+              allow_host_mutation: bool = False,
+              no_cache: bool = False) -> str:
     """Route c3_ci actions."""
     project = str(svc.project_path)
     action = (action or "inspect").strip().lower()
@@ -152,6 +156,43 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
         return finalize("c3_ci", args, "\n".join(lines),
                         f"{len(data['jobs'])} jobs, {len(data['runnable'])} runnable")
 
+    # ── plan (required mode, no execution) ───────────────────────────────
+    if action == "plan":
+        from services.ci_workflow import (
+            build_dag,
+            discover_workflows,
+            git_context,
+            parse_workflow,
+        )
+        wfs = [parse_workflow(p) for p in discover_workflows(project)]
+        dag = build_dag([w for w in wfs if not w.error],
+                        event=event, git=git_context(project))
+        try:
+            ordered = dag.topo_order()
+        except Exception:
+            ordered = dag.instances
+        plan = ci_impact.plan_required(project, ordered, wfs, base=base,
+                                       event=event)
+        lines = [
+            f"Required-mode plan ({len(plan.selected)} run / "
+            f"{len(plan.skipped)} skip) vs {base or 'the working tree'}",
+            f"changed files: {len(plan.changed)}",
+        ]
+        for path in plan.changed[:10]:
+            lines.append(f"  {path}")
+        if len(plan.changed) > 10:
+            lines.append(f"  ... and {len(plan.changed) - 10} more")
+        lines.append("")
+        for decision in plan.decisions:
+            mark = "RUN " if decision.decision == ci_impact.RUN else "skip"
+            lines.append(f"  {mark} {decision.job}")
+            lines.append(f"       {decision.reason}")
+        if plan.note:
+            lines.append(f"\n{plan.note}")
+        lines.append("\nRun it: c3_ci(action='run', mode='required')")
+        return finalize("c3_ci", args, "\n".join(lines),
+                        f"{len(plan.selected)} required")
+
     # ── run / rerun ──────────────────────────────────────────────────────
     if action in ("run", "rerun"):
         only = None
@@ -172,7 +213,9 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
                            only=only, timeout=timeout or cr.DEFAULT_STEP_TIMEOUT,
                            workflow=workflow, event=event, engine=engine,
                            allow_side_effects=allow_side_effects,
-                           network=network)
+                           network=network, mode=mode, base=base,
+                           allow_host_mutation=allow_host_mutation,
+                           no_cache=no_cache)
         run = result.to_dict()
         lines = [_verdict_line(run), f"run {run['run_id']}  host={run['host_os']}"]
         fp = run.get("fingerprint") or {}
@@ -245,6 +288,86 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
                          f"{row.get('started_at', '')[:19]}  {tally}")
         return finalize("c3_ci", args, "\n".join(lines), f"{len(rows)} runs")
 
+    # ── history / intelligence ───────────────────────────────────────────
+    if action in ("history", "intel", "flaky"):
+        from services import ci_intel
+        data = ci_intel.analyse(project)
+        if not data["runs_analysed"]:
+            return finalize("c3_ci", args, data["note"], "no history")
+        lines = [data["note"], ""]
+        if data["flaky"]:
+            lines.append("FLAKY — passed AND failed on identical inputs:")
+            for job in data["flaky"]:
+                lines.append(f"  {job['key']}  {job['failed']}/{job['executed']} failed")
+                lines.append("      same fingerprint gave both answers, so the "
+                             "code did not change between them")
+            lines.append("")
+        lines.append(f"{'job':<40}{'exec':>5}{'fail':>6}{'rate':>7}{'avg':>8}")
+        for job in data["jobs"][:15]:
+            rate = f"{job['fail_rate']:.0%}" if job["executed"] else "-"
+            avg = f"{job['avg_ms'] / 1000:.1f}s" if job["avg_ms"] else "-"
+            mark = "" if job["confident"] else "  (low n)"
+            lines.append(f"  {job['key']:<38}{job['executed']:>5}"
+                         f"{job['failed']:>6}{rate:>7}{avg:>8}{mark}")
+        if data["slowest"]:
+            lines.append("\nSlowest: " + ", ".join(
+                f"{j['key']} {j['avg_ms'] / 1000:.1f}s" for j in data["slowest"][:3]))
+        return finalize("c3_ci", args, "\n".join(lines),
+                        f"{len(data['flaky'])} flaky")
+
+    # ── publish (GitHub commit status) ───────────────────────────────────
+    if action == "publish":
+        from services import ci_github
+        run = cr.load_run(project, run_id)
+        if not run:
+            return finalize("c3_ci", args, "No run to publish.", "no runs")
+        res = ci_github.publish(project, run,
+                                force=allow_side_effects,
+                                dry_run=(job or "").lower() == "dry-run")
+        if res.get("dry_run"):
+            body = "\n".join([
+                f"Would POST {res['endpoint']}",
+                f"  state={res['state']}",
+                f"  {res['description']}",
+            ])
+            return finalize("c3_ci", args, body, "dry run")
+        if not res.get("published"):
+            return finalize("c3_ci", args,
+                            f"Not published: {res.get('reason')}", "refused")
+        body = (f"Published {res['state']} to {res['sha'][:8]} "
+                f"as {res['context']}.\n  {res['description']}")
+        return finalize("c3_ci", args, body, res["state"])
+
+    # ── cache ────────────────────────────────────────────────────────────
+    if action == "cache":
+        from services import ci_cache
+        if (job or "").strip().lower() == "clear" or run_id == "clear":
+            freed = ci_cache.clear(project)
+            return finalize("c3_ci", args,
+                            f"Cleared the CI cache ({freed / 1024:.0f} KB).",
+                            "cache cleared")
+        info = ci_cache.stats(project)
+        rules = ci_impact.load_rules(project)
+        lines = [
+            f"Cached results: {info['results']}",
+            f"Dependency cache keys: {info['dependency_keys']}",
+            f"Location: {info['dir']}",
+            "",
+            "A job is reused when its definition, engine and inputs are all "
+            "unchanged since it last passed.",
+        ]
+        if rules:
+            lines.append(
+                f"{len(rules)} job(s) declare inputs via ci.required_map, so "
+                "only those paths invalidate them.")
+        else:
+            lines.append(
+                "No ci.required_map: every job is fingerprinted over the whole "
+                "tree, so any edit invalidates every cached result. Declaring "
+                "inputs is what makes the cache bite.")
+        return finalize("c3_ci", args, "\n".join(lines),
+                        f"{info['results']} cached")
+
     # ── doctor ───────────────────────────────────────────────────────────
     if action == "doctor":
         from services import ci_act

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/tools/shell.py

@@ -69,6 +69,45 @@ _SOFT_WARN = re.compile(
 
 _DEFAULT_TIMEOUT = 60
 _MAX_TIMEOUT = 600
+
+# The transport's own ceiling, and the reason _MAX_TIMEOUT alone is a lie.
+#
+# An MCP client kills a tool call at MCP_TOOL_TIMEOUT (Claude Code ships
+# 120_000 ms and the value is set per-environment) — a limit this process does
+# not choose and cannot raise. Until this existed, `c3_shell(timeout=600)` was
+# accepted, clamped to 600, and then killed by the client at 120s with the
+# subprocess still running: the caller saw the call "moved to background" and
+# then fail, with no line anywhere naming the real limit or attributing the
+# kill. The subprocess was NOT reaped by us, because our own deadline never
+# arrived.
+#
+# The cost was not hypothetical. Two Higgsfield image generations (2-4 min
+# each) were requested at timeout=420, killed at 120s, and the remote jobs
+# completed and were BILLED while the local process died before downloading —
+# one image landed, one was paid for and stranded.
+#
+# So: discover the client's ceiling, run just inside it, and SAY SO. Running
+# inside it means OUR deadline fires first, which turns a phantom
+# client-side kill into an ordinary `[c3_shell:TIMEOUT]` with stdout, a
+# duration, and a process tree we actually killed.
+_TRANSPORT_MARGIN_S = 5
+
+
+def _transport_ceiling_s() -> int | None:
+    """Seconds this call may run before the MCP client kills it, if knowable.
+
+    None when the variable is unset or unparseable — then nothing is capped
+    and behaviour is exactly what it was, because a guess here would cap
+    legitimate work on a client with no such limit.
+    """
+    raw = (os.environ.get("MCP_TOOL_TIMEOUT") or "").strip()
+    if not raw:
+        return None
+    try:
+        ceiling = int(float(raw)) // 1000
+    except (TypeError, ValueError):
+        return None
+    return ceiling if ceiling > _TRANSPORT_MARGIN_S else None
 _FILTER_THRESHOLD_LINES = 30
 _JQ_INVOCATION = re.compile(r"(?:^|&&|\|\||[;|(])\s*jq(?:\s|$)", re.IGNORECASE)
 
@@ -468,6 +507,13 @@ async def handle_shell(cmd: str, cwd: str, timeout: int, filter_output: bool,
         )
 
     timeout = max(1, min(int(timeout or _DEFAULT_TIMEOUT), _MAX_TIMEOUT))
+    # Cap to what the transport will actually allow, and remember that we did
+    # so — the caller asked for a number, and a number quietly not honoured is
+    # the whole defect (see _transport_ceiling_s).
+    capped_from = 0
+    _ceiling = _transport_ceiling_s()
+    if _ceiling is not None and timeout > _ceiling - _TRANSPORT_MARGIN_S:
+        capped_from, timeout = timeout, _ceiling - _TRANSPORT_MARGIN_S
     work_cwd = cwd or svc.project_path
     work_cwd = str(Path(work_cwd).resolve())
 
@@ -601,6 +647,16 @@ async def handle_shell(cmd: str, cwd: str, timeout: int, filter_output: bool,
     warn = ""
     if _SOFT_WARN.search(cmd):
         warn = "[c3_shell:warn] destructive pattern detected — verify before re-running\n"
+    if capped_from:
+        # Named at the moment of the mistake, not in documentation nobody
+        # reads at the moment they need it. The alternative IS the escape
+        # hatch, so the line says which one.
+        warn += (
+            f"[c3_shell:capped] timeout={capped_from}s was requested but this "
+            f"MCP client kills a tool call at {_ceiling}s; ran with {timeout}s. "
+            f"For longer work use the native Bash tool with "
+            f"run_in_background, which is not bound by this limit.\n"
+        )
 
     if result["timed_out"]:
         status = "TIMEOUT"

{code_context_control-2.82.0 → code_context_control-2.86.0}/cli/tools/tasks.py

@@ -5,7 +5,8 @@ READ_ACTIONS = {"list", "get", "board", "history", "report",
 
 _TASK_ACTIONS = ("add, update, done, list, get, board, history, report, archive, "
                  "block, unblock, link, unlink, "
-                 "milestone_add, milestone_update, milestone_list, milestone_archive, "
+                 "milestone_add, milestone_update, milestone_list, "
+                 "milestone_complete, milestone_reopen, milestone_archive, "
                  "note_add, note_list, "
                  "time_add, time_update, time_delete, time_list, time_summary")
 
@@ -368,6 +369,26 @@ def handle_task(action, svc, finalize, *, title="", task_id="", status="",
             return done_resp(f"[task:error] {res['error']}", "error")
         return done_resp(f"[milestone:updated] {res['id'][:8]} \"{res['name']}\"", "updated")
 
+    if action == "milestone_complete":
+        if not milestone:
+            return done_resp("[task:error] milestone_complete requires milestone.", "error")
+        ms = store.resolve_milestone(milestone)
+        if ms is None:
+            return done_resp(f"[task:error] no milestone matches: {milestone}", "error")
+        res = store.complete_milestone(ms["id"])
+        if "error" in res:
+            return done_resp(f"[task:error] {res['error']}", "error")
+        return done_resp(f"[milestone:completed] \"{res['name']}\" "
+                         f"(tasks keep their milestone link)", "completed")
+
+    if action == "milestone_reopen":
+        if not milestone:
+            return done_resp("[task:error] milestone_reopen requires milestone.", "error")
+        res = store.reopen_milestone(milestone)
+        if "error" in res:
+            return done_resp(f"[task:error] {res['error']}", "error")
+        return done_resp(f"[milestone:reopened] \"{res['name']}\"", "reopened")
+
     if action == "milestone_archive":
         if not milestone:
             return done_resp("[task:error] milestone_archive requires milestone.", "error")

{code_context_control-2.82.0 → code_context_control-2.86.0/code_context_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.82.0
+Version: 2.86.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
@@ -178,7 +178,7 @@ Twelve tabs. The dashboard above shows token savings, indexed files, the live se
   <img src="https://raw.githubusercontent.com/drknowhow/code-context-control/main/docs/screenshots/2026-07/ui_tasks.png" alt="C3 Tasks" width="900">
 </p>
 
-**Tasks** (v2.45.0, extended v2.53.0) is a durable per-project tracker — dependencies and subtasks, milestones, decision notes, full event history, health reports, and both automatic and manual time tracking. It rolls up into the Hub's cross-project board.
+**Tasks** (v2.45.0, extended v2.53.0) is a durable per-project tracker — dependencies and subtasks, milestones, decision notes, full event history, health reports, and both automatic and manual time tracking. It rolls up into the Hub's cross-project board. Shipped milestones can be **completed** (v2.86.0) — they leave the board while their tasks keep the milestone link, unlike archiving, which detaches them.
 
 **Instructions** keeps your agent-facing docs in sync. C3-generated content sits inside a `<!-- C3:BEGIN … -->` block; anything you write outside it is preserved. Since v2.60.0 generated docs point at `.c3/MAP.md` — a machine-owned, byte-stable repo map C3 refreshes automatically — instead of embedding a tree that goes stale. `AGENTS.md` serves both Codex and Antigravity; `GEMINI.md` is read if present but no longer generated (the Gemini CLI profile was removed in v2.52).
 
@@ -243,6 +243,7 @@ c3 access mask activate                         # purge pre-mask artifacts, buil
 - **`deny` means deny-enumerate too** — denied paths never appear in search results, maps, or the vector index.
 - **Masked means read-only, always.** Cropped rows have no inverse, so an edit in transformed coordinates would corrupt the one file you protected.
 - **Four deterministic presets, no LLM in the read path:** `redact_secrets`, `redact_columns` (salted one-way pseudonyms — joins survive, no reverse dictionary), `sample_rows`, `signatures_only`.
+- **Sensible defaults out of the box** (v2.86.0). A fresh install seeds `*.pem`, `id_rsa*`, and `*.key` as deny rules in global scope — visible in `c3 access list` and removable like any rule you wrote yourself. Delete one and it stays deleted.
 - **Rule changes are human-only** (UI tab or CLI) and ledger-logged. Agents have no mutation surface.
 - **Built-ins can be switched off when you need to** (v2.65.0). `**/.env*`, `**/.c3/**`, `**/.claude/settings*.json` and `**/.git/**` yield to `c3 access builtin disable <glob>`, which makes you retype the glob first. It takes **two keys** — a config entry *and* a keyring attestation — so an agent that manages to write `config.json` still cannot grant itself write access to your settings. The credential vault stays absolute.
 - **Honest coverage.** This guards *cooperative* agents against mistakes and prompt injection. It is not a sandbox — a raw shell outside C3's tools still sees the real bytes.

{code_context_control-2.82.0 → code_context_control-2.86.0}/code_context_control.egg-info/SOURCES.txt

@@ -186,8 +186,12 @@ services/benchmark_dashboard.py
 services/bitbucket_client.py
 services/bitbucket_credentials.py
 services/ci_act.py
+services/ci_cache.py
 services/ci_expr.py
 services/ci_failures.py
+services/ci_github.py
+services/ci_impact.py
+services/ci_intel.py
 services/ci_runner.py
 services/ci_workflow.py
 services/circuit_breaker.py
@@ -283,7 +287,10 @@ tests/test_c3_bridge_project_artifacts.py
 tests/test_c3_shell.py
 tests/test_chat_poll.py
 tests/test_ci_act.py
+tests/test_ci_cache.py
 tests/test_ci_expr.py
+tests/test_ci_impact.py
+tests/test_ci_intel.py
 tests/test_ci_runner.py
 tests/test_ci_workflow.py
 tests/test_circuit_breaker.py