core-runtime 0.1.1__py3-none-any.whl

body/services/policy_expression_evaluator.py

@@ -0,0 +1,154 @@
+# src/body/services/policy_expression_evaluator.py
+
+"""
+Policy Expression Evaluator - Safe Boolean Expression Evaluation
+
+CONSTITUTIONAL ALIGNMENT:
+- Single Responsibility: Evaluate policy expressions safely
+- No CLI dependencies
+- Reusable for governance checks
+
+Extracted from cli/logic/validate.py to separate evaluation logic.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+# ID: 24950f8a-5412-483a-9af7-e02427769ee7
+class ReviewContext:
+    """Context for policy expression evaluation."""
+
+    risk_tier: str = "low"
+    score: float = 0.0
+    touches_critical_paths: bool = False
+    checkpoint: bool = False
+    canary: bool = False
+    approver_quorum: bool = False
+
+
+# ID: e09d9c07-2e67-4e7a-a58c-2c647dd354a1
+class PolicyExpressionEvaluator:
+    """
+    Safely evaluates boolean policy expressions.
+
+    SECURITY: Uses AST validation to ensure only safe operations.
+    No arbitrary code execution possible.
+
+    Usage:
+        evaluator = PolicyExpressionEvaluator()
+        context = {"risk_tier": "high", "checkpoint": True}
+        result = evaluator.evaluate("risk_tier == 'high' and checkpoint", context)
+    """
+
+    # AST allowlist for safe policy evaluation
+    _ALLOWED_NODES: ClassVar[set[type]] = {
+        ast.Expression,
+        ast.BoolOp,
+        ast.BinOp,
+        ast.UnaryOp,
+        ast.Compare,
+        ast.Name,
+        ast.Load,
+        ast.Constant,
+        ast.List,
+        ast.Tuple,
+        ast.And,
+        ast.Or,
+        ast.Not,
+        ast.In,
+        ast.Eq,
+        ast.NotEq,
+    }
+
+    # ID: a1c30251-1e32-459c-bf1d-44b6f649c7b6
+    def evaluate(self, expr: str, context: dict[str, Any]) -> bool:
+        """
+        Safely evaluate a boolean expression string against a context dictionary.
+
+        SECURITY NOTE: This function uses eval() but is SAFE because:
+        1. Input is parsed and validated via AST whitelist
+        2. Only safe nodes are permitted (no calls, imports, attribute access)
+        3. Builtins are disabled ({"__builtins__": {}})
+        4. Only whitelisted context variables are available
+        5. Used exclusively for evaluating policy conditions from .intent/
+
+        This is verified safe code execution for constitutional governance.
+
+        Args:
+            expr: Boolean expression string
+            context: Dictionary of allowed variables
+
+        Returns:
+            Evaluation result
+
+        Raises:
+            ValueError: If expression contains disallowed operations
+        """
+        # Normalize boolean literals
+        expr = expr.replace(" true", " True").replace(" false", " False")
+
+        # Layer 1: Parse to AST
+        try:
+            tree = ast.parse(expr, mode="eval")
+        except SyntaxError as e:
+            raise ValueError(f"Invalid expression syntax: {e}") from e
+
+        # Layer 2: AST Validation
+        for node in ast.walk(tree):
+            if type(node) not in self._ALLOWED_NODES:
+                raise ValueError(
+                    f"Disallowed node in expression: {type(node).__name__}"
+                )
+
+        # Layer 3: Restricted Execution (Sandboxing)
+        # SECURITY: Using compile() on validated AST is safer than eval(str)
+        # SECURITY: __builtins__ is empty to prevent access to globals
+        compiled = compile(tree, "<policy_expr>", "eval")
+
+        # SECURITY: context variables only
+        try:
+            return bool(eval(compiled, {"__builtins__": {}}, context))
+        except Exception as e:
+            raise ValueError(f"Expression evaluation failed: {e}") from e
+
+    # ID: 0d1e2f3a-4b5c-6d7e-8f9a-0b1c2d3e4f5a
+    def validate_expression(self, expr: str) -> tuple[bool, str | None]:
+        """
+        Validate expression without evaluating it.
+
+        Args:
+            expr: Expression to validate
+
+        Returns:
+            (is_valid, error_message)
+        """
+        try:
+            # Normalize
+            expr = expr.replace(" true", " True").replace(" false", " False")
+
+            # Parse
+            tree = ast.parse(expr, mode="eval")
+
+            # Validate nodes
+            for node in ast.walk(tree):
+                if type(node) not in self._ALLOWED_NODES:
+                    return (
+                        False,
+                        f"Disallowed operation: {type(node).__name__}",
+                    )
+
+            return True, None
+        except SyntaxError as e:
+            return False, f"Syntax error: {e}"
+        except Exception as e:
+            return False, f"Validation error: {e}"

body/services/proposal_supervision_service.py

@@ -0,0 +1,187 @@
+# src/body/services/proposal_supervision_service.py
+"""
+ProposalSupervisionService - Data-access layer for proposal pipeline health.
+
+Body-layer service exposing the three supervisory queries the
+ProposalPipelineShopManager needs against core.autonomous_proposals:
+
+- fetch_stuck_approved:    rows in status='approved' older than SLA
+- fetch_stuck_executing:   rows in status='executing' older than SLA
+- fetch_repeated_failures: (first action_id, source_check_id) pairs
+                           with status='failed' count >= threshold
+                           within the lookback window
+
+Constitutional alignment:
+- Layer:    body — data-access only, no decisions
+- Boundary: no Will imports, no domain reasoning, no LLM
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from sqlalchemy import text
+
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+
+# ID: 0e4dacfe-1f57-4978-b30d-94ebea06f862
+class ProposalSupervisionService:
+    """
+    Body layer service. Exposes named methods for the three
+    proposal-pipeline-health queries used by ProposalPipelineShopManager.
+
+    All methods open their own session via ServiceRegistry — callers do
+    not pass one in. This matches the AuditFindingsService /
+    WorkerRegistryService pattern.
+    """
+
+    # ID: b9263f77-0a50-4fb1-a845-2e91c7e25eb4
+    async def fetch_stuck_approved(
+        self, sla_sec: int, limit: int
+    ) -> list[dict[str, Any]]:
+        """
+        Return proposals stuck in status='approved' beyond the SLA.
+
+        Each row carries the proposal_id, approved_at, and seconds_stuck
+        so the worker can build a precise finding payload.
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        cutoff = datetime.now(UTC) - timedelta(seconds=sla_sec)
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    """
+                    SELECT
+                        proposal_id,
+                        approved_at,
+                        EXTRACT(EPOCH FROM (now() - approved_at))::int AS seconds_stuck
+                    FROM core.autonomous_proposals
+                    WHERE status = 'approved'
+                      AND approved_at IS NOT NULL
+                      AND approved_at < :cutoff
+                    ORDER BY approved_at ASC
+                    LIMIT :limit
+                    """
+                ),
+                {"cutoff": cutoff, "limit": limit},
+            )
+            rows = result.fetchall()
+
+        return [
+            {
+                "proposal_id": str(row[0]),
+                "approved_at": row[1],
+                "seconds_stuck": int(row[2]),
+            }
+            for row in rows
+        ]
+
+    # ID: ed19598e-6d0f-431d-897b-e5f69bc4c78a
+    async def fetch_stuck_executing(
+        self, sla_sec: int, limit: int
+    ) -> list[dict[str, Any]]:
+        """
+        Return proposals stuck in status='executing' beyond the SLA.
+
+        Uses execution_started_at as the anchor (not updated_at — that
+        moves on any UPDATE and would hide a genuinely stuck row).
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        cutoff = datetime.now(UTC) - timedelta(seconds=sla_sec)
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    """
+                    SELECT
+                        proposal_id,
+                        execution_started_at,
+                        EXTRACT(EPOCH FROM (now() - execution_started_at))::int
+                            AS seconds_stuck
+                    FROM core.autonomous_proposals
+                    WHERE status = 'executing'
+                      AND execution_started_at IS NOT NULL
+                      AND execution_started_at < :cutoff
+                    ORDER BY execution_started_at ASC
+                    LIMIT :limit
+                    """
+                ),
+                {"cutoff": cutoff, "limit": limit},
+            )
+            rows = result.fetchall()
+
+        return [
+            {
+                "proposal_id": str(row[0]),
+                "execution_started_at": row[1],
+                "seconds_stuck": int(row[2]),
+            }
+            for row in rows
+        ]
+
+    # ID: 3f325bf4-3f14-4b15-bcfa-17a64f8c56db
+    async def fetch_repeated_failures(
+        self,
+        threshold: int,
+        lookback_sec: int,
+        limit: int,
+    ) -> list[dict[str, Any]]:
+        """
+        Return (action_id, rule_id) pairs whose proposals have failed
+        at least *threshold* times within the lookback window.
+
+        Action_id is read from actions[0]->>'action_id' — the first
+        action of the proposal, by design decision (the secondary-
+        action variant is deferred; see #170 design notes).
+
+        Rule_id is read from constitutional_constraints->>'source_check_id',
+        the conventional key for the audit rule that triggered the
+        autonomous proposal.
+        """
+        from body.services.service_registry import ServiceRegistry
+
+        since = datetime.now(UTC) - timedelta(seconds=lookback_sec)
+
+        async with ServiceRegistry.session() as session:
+            result = await session.execute(
+                text(
+                    """
+                    SELECT
+                        actions->0->>'action_id'                          AS action_id,
+                        constitutional_constraints->>'source_check_id'    AS rule_id,
+                        COUNT(*)                                          AS failure_count,
+                        MAX(updated_at)                                   AS last_failure_at,
+                        array_agg(proposal_id ORDER BY updated_at DESC)   AS proposal_ids
+                    FROM core.autonomous_proposals
+                    WHERE status = 'failed'
+                      AND updated_at >= :since
+                      AND actions->0->>'action_id' IS NOT NULL
+                      AND constitutional_constraints->>'source_check_id' IS NOT NULL
+                    GROUP BY action_id, rule_id
+                    HAVING COUNT(*) >= :threshold
+                    ORDER BY failure_count DESC, last_failure_at DESC
+                    LIMIT :limit
+                    """
+                ),
+                {"since": since, "threshold": threshold, "limit": limit},
+            )
+            rows = result.fetchall()
+
+        return [
+            {
+                "action_id": str(row[0]),
+                "rule_id": str(row[1]),
+                "failure_count": int(row[2]),
+                "last_failure_at": row[3],
+                "proposal_ids": [str(p) for p in (row[4] or [])][:5],
+            }
+            for row in rows
+        ]

body/services/representation_coherence_service.py

@@ -0,0 +1,209 @@
+# src/body/services/representation_coherence_service.py
+
+"""
+RepresentationCoherenceService — Body layer service for ADR-070 D6 verdict line.
+
+Governing ADR: .specs/decisions/ADR-070-source-projection-coherence.md
+
+Constitutional Compliance:
+- Body layer service: provides DB access without making decisions.
+- Reads .intent/governance/projections.yaml (inventory) and derives per-pair
+  state from existing observable signals (blackboard reports, worker_registry
+  heartbeats, open findings under each pair's rule_id).
+- No business logic about remediation — the service reports, it does not
+  prescribe. Drift is named through the existing finding lifecycle; this
+  service only summarizes.
+
+Used by: src/cli/resources/code/audit.py (D6 composite verdict line)
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+import yaml
+from sqlalchemy import text
+
+from body.services.session_attached_service import SessionAttachedService
+from shared.logger import getLogger
+
+
+logger = getLogger(__name__)
+
+__all__ = ["RepresentationCoherenceService"]
+
+
+_INVENTORY_PATH = Path(".intent/governance/projections.yaml")
+
+# How long a writer-as-sensor pair's signal stays "fresh" before being
+# considered sensor-stale. Conservative default — 2x the longest declared
+# crawler interval (600s in repo_crawler.yaml) gives 1200s. Per-pair
+# overrides via inventory entry's `freshness_seconds` field when present.
+_DEFAULT_FRESHNESS_SECONDS = 1200
+
+
+# ID: 6a8d9c1e-2b4f-4d3a-9c7e-5f8b1a3d6c9e
+class RepresentationCoherenceService(SessionAttachedService):
+    """
+    Reads the projection inventory and derives per-pair coherence state.
+
+    Returns aggregated state for the audit advisory line (ADR-070 D6).
+    Per-pair details surface through findings under each pair's rule_id;
+    this service produces the summary roll-up only.
+    """
+
+    # ID: a3f5d7c9-1e2b-4a6d-8c9f-3e5d7b9c1a4e
+    async def get_summary(self) -> dict[str, Any]:
+        """
+        Return a roll-up of inventory state for the audit advisory line.
+
+        Returns:
+            {
+                "inventory_loaded": bool,
+                "pairs_declared": int,
+                "in_lease": int,
+                "drifted": int,
+                "sensor_stale": int,
+                "last_check_at": datetime | None,
+            }
+
+        `inventory_loaded=False` indicates the inventory file is absent or
+        unreadable. `pairs_declared=0` with loaded=True indicates the
+        inventory exists but declares no pairs (pre-first-pair state).
+        """
+        inventory = _load_inventory()
+        if inventory is None:
+            return {
+                "inventory_loaded": False,
+                "pairs_declared": 0,
+                "in_lease": 0,
+                "drifted": 0,
+                "sensor_stale": 0,
+                "last_check_at": None,
+            }
+
+        pairs = inventory.get("projections", []) or []
+        if not pairs:
+            return {
+                "inventory_loaded": True,
+                "pairs_declared": 0,
+                "in_lease": 0,
+                "drifted": 0,
+                "sensor_stale": 0,
+                "last_check_at": None,
+            }
+
+        in_lease = 0
+        drifted = 0
+        sensor_stale = 0
+        latest_check: datetime | None = None
+
+        for pair in pairs:
+            state = await self._get_pair_state(pair)
+            if state["status"] == "in_lease":
+                in_lease += 1
+            elif state["status"] == "drifted":
+                drifted += 1
+            elif state["status"] == "sensor_stale":
+                sensor_stale += 1
+
+            if state["last_check_at"] is not None:
+                if latest_check is None or state["last_check_at"] > latest_check:
+                    latest_check = state["last_check_at"]
+
+        return {
+            "inventory_loaded": True,
+            "pairs_declared": len(pairs),
+            "in_lease": in_lease,
+            "drifted": drifted,
+            "sensor_stale": sensor_stale,
+            "last_check_at": latest_check,
+        }
+
+    async def _get_pair_state(self, pair: dict[str, Any]) -> dict[str, Any]:
+        """
+        Derive the current state of one projection pair.
+
+        States:
+          - in_lease:     sensor recently heartbeated; no open drift findings
+          - drifted:      one or more open findings under the pair's rule_id
+          - sensor_stale: sensor has not heartbeated within the freshness window
+        """
+        session = self._require_session()
+        sensor_worker_name = pair.get("sensor_worker", "")
+        rule_id = pair.get("rule_id", "")
+        freshness_seconds = pair.get("freshness_seconds", _DEFAULT_FRESHNESS_SECONDS)
+
+        # Most recent heartbeat for the declared sensor worker.
+        heartbeat_result = await session.execute(
+            text(
+                """
+                SELECT last_heartbeat
+                FROM core.worker_registry
+                WHERE declaration_name = :name
+                ORDER BY last_heartbeat DESC NULLS LAST
+                LIMIT 1
+                """
+            ),
+            {"name": sensor_worker_name},
+        )
+        heartbeat_row = heartbeat_result.fetchone()
+        last_heartbeat: datetime | None = heartbeat_row[0] if heartbeat_row else None
+
+        # Sensor-stale check: if no heartbeat at all, OR last heartbeat older
+        # than the freshness window, the sensor is not observable.
+        if last_heartbeat is None:
+            return {"status": "sensor_stale", "last_check_at": None}
+        now = datetime.now(UTC)
+        # Heartbeats persist as TIMESTAMPTZ but may be returned naive on some
+        # drivers; coerce defensively.
+        if last_heartbeat.tzinfo is None:
+            last_heartbeat = last_heartbeat.replace(tzinfo=UTC)
+        if now - last_heartbeat > timedelta(seconds=freshness_seconds):
+            return {"status": "sensor_stale", "last_check_at": last_heartbeat}
+
+        # Drift check: any open findings under this pair's rule_id.
+        # Writer-as-sensor pairs (remediation.mode: inline) post findings
+        # with status='resolved' directly, so they never count as drifted
+        # here even when a reap happened — which is the correct semantic
+        # per ADR-070 D4 (drift was detected and immediately remediated).
+        if rule_id:
+            drift_result = await session.execute(
+                text(
+                    """
+                    SELECT count(*) FROM core.blackboard_entries
+                    WHERE entry_type = 'finding'
+                      AND subject = :rule_id
+                      AND status = 'open'
+                    """
+                ),
+                {"rule_id": rule_id},
+            )
+            open_count = int(drift_result.scalar_one() or 0)
+            if open_count > 0:
+                return {"status": "drifted", "last_check_at": last_heartbeat}
+
+        return {"status": "in_lease", "last_check_at": last_heartbeat}
+
+
+def _load_inventory() -> dict[str, Any] | None:
+    """
+    Load the projection inventory from .intent/governance/projections.yaml.
+
+    Returns None if the file is absent or unparseable — the audit advisory
+    line treats this as "no pairs declared." A failure to load is not
+    raised because the advisory line must not block audit completion.
+    """
+    if not _INVENTORY_PATH.exists():
+        return None
+    try:
+        return yaml.safe_load(_INVENTORY_PATH.read_text(encoding="utf-8"))
+    except Exception as exc:
+        logger.warning(
+            "RepresentationCoherenceService: failed to load %s: %s",
+            _INVENTORY_PATH,
+            exc,
+        )
+        return None