devcouncil 0.3.0 → 0.4.0

package/src/devcouncil/execution/stop_gate_history.py

@@ -0,0 +1,113 @@
+"""Persist stop-gate events under ``.devcouncil/logs/stop_gate.jsonl``."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from devcouncil.verification.claims.models import CheckResult
+
+CLAIM_CAP = 500
+DETAIL_CAP = 2000
+HISTORY_REL = Path(".devcouncil") / "logs" / "stop_gate.jsonl"
+
+
+def history_path(project_root: Path) -> Path:
+    return project_root / HISTORY_REL
+
+
+def build_event(
+    *,
+    session_id: str,
+    decision: str,
+    claim: str = "",
+    results: list[CheckResult] | None = None,
+    task_id: str | None = None,
+    blocking_gaps: int = 0,
+    mode: str = "",
+    extra: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    event: dict[str, Any] = {
+        "ts": time.time(),
+        "session_id": session_id,
+        "claim": (claim or "")[:CLAIM_CAP],
+        "decision": decision,
+        "task_id": task_id,
+        "blocking_gaps": blocking_gaps,
+        "mode": mode,
+        "results": [
+            {
+                "kind": r.assertion.kind.value,
+                "target": r.assertion.target,
+                "status": r.status.value,
+                "source": r.assertion.source_text[:CLAIM_CAP],
+                "detail": r.detail[:DETAIL_CAP],
+            }
+            for r in (results or [])
+        ],
+    }
+    if extra:
+        event.update(extra)
+    return event
+
+
+def append_event(project_root: Path, event: dict[str, Any]) -> None:
+    try:
+        path = history_path(project_root)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "a", encoding="utf-8") as fh:
+            fh.write(json.dumps(event) + "\n")
+    except (OSError, TypeError, ValueError):
+        pass
+
+
+def read_events(project_root: Path, limit: int = 500) -> list[dict[str, Any]]:
+    """Events newest-first; corrupt lines skipped."""
+    try:
+        lines = history_path(project_root).read_text(encoding="utf-8-sig", errors="replace").splitlines()
+    except OSError:
+        return []
+    events: list[dict[str, Any]] = []
+    for line in reversed(lines):
+        if len(events) >= limit:
+            break
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(event, dict):
+            events.append(event)
+    return events
+
+
+def session_tally(project_root: Path, session_id: str) -> tuple[int, int]:
+    """Return (pass_or_allow_count, fail_or_block_count) for a session."""
+    if not session_id:
+        return 0, 0
+    ok = 0
+    bad = 0
+    for event in read_events(project_root, limit=2000):
+        if event.get("session_id") != session_id:
+            continue
+        decision = str(event.get("decision") or "")
+        if decision in {"block", "assist"}:
+            # assist with failures still counts as a miss for the shield tally
+            results = event.get("results") or []
+            has_fail = any(isinstance(r, dict) and r.get("status") == "fail" for r in results)
+            if decision == "block" or has_fail or event.get("blocking_gaps", 0):
+                bad += 1
+            else:
+                ok += 1
+        elif decision in {"pass", "allow"}:
+            ok += 1
+    return ok, bad
+
+
+def last_event(project_root: Path) -> dict[str, Any] | None:
+    events = read_events(project_root, limit=1)
+    return events[0] if events else None

package/src/devcouncil/execution/stop_gate_state.py

@@ -0,0 +1,54 @@
+"""Per-session block-count state under ``.devcouncil/state/stop_gate_blocks.json``."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from devcouncil.utils.json_persist import read_json, write_json
+
+STATE_REL = Path(".devcouncil") / "state" / "stop_gate_blocks.json"
+
+
+def state_path(project_root: Path) -> Path:
+    return project_root / STATE_REL
+
+
+def get_block_count(project_root: Path, session_id: str) -> int:
+    if not session_id:
+        return 0
+    try:
+        data = read_json(state_path(project_root)) or {}
+        if not isinstance(data, dict):
+            return 0
+        sessions = data.get("sessions") or {}
+        if not isinstance(sessions, dict):
+            return 0
+        count = sessions.get(session_id, 0)
+        return count if isinstance(count, int) and count >= 0 else 0
+    except (OSError, json.JSONDecodeError, TypeError, AttributeError):
+        return 0
+
+
+def increment_block_count(project_root: Path, session_id: str) -> int:
+    if not session_id:
+        return 0
+    path = state_path(project_root)
+    try:
+        try:
+            data = read_json(path) or {}
+        except FileNotFoundError:
+            data = {}
+        if not isinstance(data, dict):
+            data = {}
+        sessions = data.setdefault("sessions", {})
+        if not isinstance(sessions, dict):
+            sessions = {}
+            data["sessions"] = sessions
+        count = get_block_count(project_root, session_id) + 1
+        sessions[session_id] = count
+        path.parent.mkdir(parents=True, exist_ok=True)
+        write_json(path, data)
+        return count
+    except (OSError, TypeError, ValueError):
+        return get_block_count(project_root, session_id) + 1

package/src/devcouncil/execution/stop_gate_verify_cache.py

@@ -0,0 +1,69 @@
+"""Short-lived cache of active-task verify outcomes for the stop gate.
+
+When MCP ``verify_task`` / ``verify-leased`` finishes, the result is recorded so
+the Stop hook can skip a full re-verify if the cache is still fresh.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any
+
+from devcouncil.utils.json_persist import read_json, write_json
+
+CACHE_REL = Path(".devcouncil") / "cache" / "stop_gate_verify.json"
+DEFAULT_TTL_MINUTES = 5
+
+
+def cache_path(project_root: Path) -> Path:
+    return project_root / CACHE_REL
+
+
+def record_verify_cache(
+    project_root: Path,
+    *,
+    task_id: str,
+    status: str,
+    blocking_gaps: int,
+    next_actions: list[dict[str, Any]] | None = None,
+    passed: bool | None = None,
+) -> None:
+    try:
+        payload = {
+            "task_id": task_id,
+            "status": status,
+            "blocking_gaps": blocking_gaps,
+            "passed": passed if passed is not None else blocking_gaps == 0,
+            "next_actions": (next_actions or [])[:20],
+            "updated_at": time.time(),
+        }
+        path = cache_path(project_root)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        write_json(path, payload)
+    except (OSError, TypeError, ValueError):
+        pass
+
+
+def load_verify_cache(
+    project_root: Path,
+    *,
+    task_id: str,
+    ttl_minutes: int = DEFAULT_TTL_MINUTES,
+) -> dict[str, Any] | None:
+    if ttl_minutes <= 0:
+        return None
+    try:
+        data = read_json(cache_path(project_root))
+    except (OSError, TypeError, ValueError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    if data.get("task_id") != task_id:
+        return None
+    updated = data.get("updated_at")
+    if not isinstance(updated, (int, float)):
+        return None
+    if time.time() - float(updated) > ttl_minutes * 60:
+        return None
+    return data