@jaguilar87/gaia-ops 4.4.0 → 4.7.2

package/hooks/modules/audit/metrics.py

@@ -1,213 +1,134 @@
 """
-Metrics collection and aggregation.
+Metrics aggregation from audit logs.
 
-Collects execution metrics and provides FUNCTIONAL generate_summary.
+Reads audit-*.jsonl files (the single source of truth for execution data)
+and produces aggregated summaries. No write path — audit/logger.py owns writes.
 """
 
 import json
 import logging
-import os
 from pathlib import Path
 from datetime import datetime, timedelta
 from typing import Dict, Any, List, Optional
 from collections import defaultdict
 
-from ..core.paths import get_metrics_dir
+from ..core.paths import get_logs_dir
 
 logger = logging.getLogger(__name__)
 
 
-class MetricsCollector:
-    """Collect and aggregate execution metrics."""
-
-    def __init__(self, metrics_dir: Optional[Path] = None):
-        """
-        Initialize metrics collector.
-
-        Args:
-            metrics_dir: Override metrics directory (for testing)
-        """
-        if metrics_dir is not None:
-            self.metrics_dir = Path(metrics_dir) if isinstance(metrics_dir, str) else metrics_dir
-        else:
-            self.metrics_dir = get_metrics_dir()
-        self.metrics_dir.mkdir(parents=True, exist_ok=True)
-
-    def record_execution(
-        self,
-        tool_name: str,
-        command: str,
-        duration: float,
-        success: bool,
-        tier: str = "unknown"
-    ) -> None:
-        """
-        Record execution metrics.
-
-        Args:
-            tool_name: Name of the tool
-            command: Command executed
-            duration: Duration in seconds
-            success: Whether execution succeeded
-            tier: Security tier
-        """
-        timestamp = datetime.now().isoformat()
-
-        metrics_record = {
-            "timestamp": timestamp,
-            "tool_name": tool_name,
-            "command_type": self._classify_command(command),
-            "duration_ms": round(duration * 1000, 2),
-            # NOTE: 'success' field removed -- Claude Code's PostToolUse hook
-            # always reports success=True due to API limitation, making the
-            # field unreliable. Use exit_code from audit logs instead.
-            "tier": tier,
-        }
-
-        # Metrics files are a strict subset of audit logs (audit-*.jsonl).
-        # Writing is disabled by default; audit logs are the SSOT for command metrics.
-        # Set GAIA_WRITE_METRICS=1 to re-enable for backward compatibility.
-        if os.environ.get("GAIA_WRITE_METRICS") == "1":
-            metrics_file = self.metrics_dir / f"metrics-{datetime.now().strftime('%Y-%m')}.jsonl"
-            try:
-                with open(metrics_file, "a") as f:
-                    f.write(json.dumps(metrics_record) + "\n")
-            except Exception as e:
-                logger.error(f"Error writing metrics: {e}")
-
-    def _classify_command(self, command: str) -> str:
-        """Classify command type for metrics."""
-        command_lower = command.lower()
-        classifiers = [
-            ("terraform", "terraform"),
-            ("kubectl", "kubernetes"),
-            ("helm", "helm"),
-            ("gcloud", "gcp"),
-            ("aws", "aws"),
-            ("flux", "flux"),
-            ("docker", "docker"),
-            ("git", "git"),
-        ]
-        for keyword, classification in classifiers:
-            if keyword in command_lower:
-                return classification
-        return "general"
-
-    def generate_summary(self, days: int = 7) -> Dict[str, Any]:
-        """
-        Generate FUNCTIONAL metrics summary for the last N days.
-
-        Args:
-            days: Number of days to include
-
-        Returns:
-            Dictionary with aggregated metrics
-        """
-        cutoff_date = datetime.now() - timedelta(days=days)
-        records = self._load_records_since(cutoff_date)
-
-        if not records:
-            return {
-                "period_days": days,
-                "total_executions": 0,
-                "success_rate": 0.0,
-                "avg_duration_ms": 0.0,
-                "top_commands": [],
-                "tier_distribution": {},
-                "command_type_distribution": {},
-            }
-
-        # Calculate metrics
-        total = len(records)
-        successes = sum(1 for r in records if r.get("success", True))
-        total_duration = sum(r.get("duration_ms", 0) for r in records)
-
-        # Count by command type
-        command_types = defaultdict(int)
-        for r in records:
-            command_types[r.get("command_type", "unknown")] += 1
-
-        # Count by tier
-        tiers = defaultdict(int)
-        for r in records:
-            tiers[r.get("tier", "unknown")] += 1
-
-        # Top command types
-        top_commands = sorted(
-            command_types.items(),
-            key=lambda x: x[1],
-            reverse=True
-        )[:10]
-
-        return {
-            "period_days": days,
-            "total_executions": total,
-            "success_rate": round(successes / total, 4) if total > 0 else 0.0,
-            "avg_duration_ms": round(total_duration / total, 2) if total > 0 else 0.0,
-            "top_commands": [{"type": t, "count": c} for t, c in top_commands],
-            "tier_distribution": dict(tiers),
-            "command_type_distribution": dict(command_types),
-            "generated_at": datetime.now().isoformat(),
-        }
-
-    def _load_records_since(self, cutoff_date: datetime) -> List[Dict]:
-        """Load all records since cutoff date."""
-        records = []
+def _classify_command(command: str) -> str:
+    """Classify command type for metrics aggregation."""
+    command_lower = command.lower()
+    classifiers = [
+        ("terraform", "terraform"),
+        ("kubectl", "kubernetes"),
+        ("helm", "helm"),
+        ("gcloud", "gcp"),
+        ("aws", "aws"),
+        ("flux", "flux"),
+        ("docker", "docker"),
+        ("git", "git"),
+    ]
+    for keyword, classification in classifiers:
+        if keyword in command_lower:
+            return classification
+    return "general"
+
+
+def _load_audit_records_since(
+    logs_dir: Path, cutoff_date: datetime
+) -> List[Dict]:
+    """Load audit records from audit-*.jsonl files since cutoff date."""
+    records = []
+
+    try:
+        audit_files = list(logs_dir.glob("audit-*.jsonl"))
+    except Exception as e:
+        logger.error(f"Error listing audit files: {e}")
+        return records
 
-        # Get all metrics files
+    for audit_file in audit_files:
         try:
-            metrics_files = list(self.metrics_dir.glob("metrics-*.jsonl"))
+            with open(audit_file, "r") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        record = json.loads(line)
+                        record_time = datetime.fromisoformat(
+                            record.get("timestamp", "")
+                        )
+                        if record_time >= cutoff_date:
+                            records.append(record)
+                    except (json.JSONDecodeError, ValueError):
+                        continue
         except Exception as e:
-            logger.error(f"Error listing metrics files: {e}")
-            return records
-
-        for metrics_file in metrics_files:
-            try:
-                with open(metrics_file, "r") as f:
-                    for line in f:
-                        line = line.strip()
-                        if not line:
-                            continue
-                        try:
-                            record = json.loads(line)
-                            record_time = datetime.fromisoformat(
-                                record.get("timestamp", "")
-                            )
-                            if record_time >= cutoff_date:
-                                records.append(record)
-                        except (json.JSONDecodeError, ValueError):
-                            continue
-            except Exception as e:
-                logger.debug(f"Error reading {metrics_file}: {e}")
-
-        return records
+            logger.debug(f"Error reading {audit_file}: {e}")
 
+    return records
 
-# Singleton collector
-_metrics_collector: Optional[MetricsCollector] = None
 
+def generate_summary(
+    days: int = 7, logs_dir: Optional[Path] = None
+) -> Dict[str, Any]:
+    """
+    Generate metrics summary from audit logs for the last N days.
 
-def get_metrics_collector() -> MetricsCollector:
-    """Get singleton metrics collector."""
-    global _metrics_collector
-    if _metrics_collector is None:
-        _metrics_collector = MetricsCollector()
-    return _metrics_collector
+    Args:
+        days: Number of days to include
+        logs_dir: Override logs directory (for testing)
 
+    Returns:
+        Dictionary with aggregated metrics:
+        - period_days, total_executions, avg_duration_ms
+        - top_commands (by classified command_type)
+        - tier_distribution, command_type_distribution
+    """
+    if logs_dir is None:
+        logs_dir = get_logs_dir()
 
-def record_metric(
-    tool_name: str,
-    command: str,
-    duration: float,
-    success: bool,
-    tier: str = "unknown"
-) -> None:
-    """Record execution metric (convenience function)."""
-    get_metrics_collector().record_execution(
-        tool_name, command, duration, success, tier
-    )
+    cutoff_date = datetime.now() - timedelta(days=days)
+    records = _load_audit_records_since(logs_dir, cutoff_date)
 
+    if not records:
+        return {
+            "period_days": days,
+            "total_executions": 0,
+            "avg_duration_ms": 0.0,
+            "top_commands": [],
+            "tier_distribution": {},
+            "command_type_distribution": {},
+        }
 
-def generate_summary(days: int = 7) -> Dict[str, Any]:
-    """Generate metrics summary (convenience function)."""
-    return get_metrics_collector().generate_summary(days)
+    total = len(records)
+    total_duration = sum(r.get("duration_ms", 0) for r in records)
+
+    # Classify commands from audit log 'command' field
+    command_types = defaultdict(int)
+    for r in records:
+        cmd = r.get("command", "")
+        command_types[_classify_command(cmd)] += 1
+
+    # Count by tier
+    tiers = defaultdict(int)
+    for r in records:
+        tiers[r.get("tier", "unknown")] += 1
+
+    # Top command types
+    top_commands = sorted(
+        command_types.items(),
+        key=lambda x: x[1],
+        reverse=True,
+    )[:10]
+
+    return {
+        "period_days": days,
+        "total_executions": total,
+        "avg_duration_ms": round(total_duration / total, 2) if total > 0 else 0.0,
+        "top_commands": [{"type": t, "count": c} for t, c in top_commands],
+        "tier_distribution": dict(tiers),
+        "command_type_distribution": dict(command_types),
+        "generated_at": datetime.now().isoformat(),
+    }

package/hooks/modules/audit/workflow_auditor.py

@@ -5,7 +5,6 @@ Renamed from anomaly_detector.py and expanded with additional anomaly types.
 
 Provides:
     - audit(): Full anomaly detection suite -> list of anomaly dicts
-    - detect_anomalies(): Backward-compatible alias for audit()
     - signal_gaia_analysis(): Create flag file for Gaia analysis
 """
 
@@ -529,9 +528,6 @@ def audit(
     return anomalies
 
 
-# Backward-compatible alias
-detect_anomalies = audit
-
 
 def signal_gaia_analysis(
     anomalies: List[Dict],

package/hooks/modules/audit/workflow_recorder.py

@@ -6,7 +6,6 @@ Renamed from metrics_recorder.py for clarity.
 Provides:
     - get_workflow_memory_dir(): Resolve workflow memory directory
     - record(): Build metrics dict, write to JSONL
-    - capture_workflow_metrics(): Backward-compatible alias for record()
 """
 
 import json
@@ -295,7 +294,3 @@ def record(
     )
 
     return metrics
-
-
-# Backward-compatible alias
-capture_workflow_metrics = record

package/hooks/modules/context/compact_context_builder.py

@@ -3,6 +3,7 @@
 Builds a lightweight context summary from session data sources.
 Each source is independent and fail-safe.
 """
+from __future__ import annotations
 
 import json
 import logging

package/hooks/modules/context/context_cache.py

@@ -0,0 +1,129 @@
+"""
+Context cache for PreToolUse -> SubagentStart handoff.
+
+PreToolUse:Agent builds context (needs the prompt for surface routing) but the
+context must reach the subagent, not the orchestrator.  SubagentStart is where
+context should be injected, but SubagentStart does not receive the prompt.
+
+Solution: PreToolUse caches the built context to a temp file keyed by
+session_id.  SubagentStart reads and consumes the cache (one-shot).
+
+Cache location: /tmp/gaia-context-cache/{session_id}-{timestamp}.json
+TTL: 60 seconds (stale files cleaned on write).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+CACHE_DIR = Path("/tmp/gaia-context-cache")
+CACHE_TTL_SECONDS = 60
+
+
+def write_context_cache(
+    session_id: str,
+    context: str,
+    agent_type: str = "",
+) -> Path:
+    """Write context to a cache file for later consumption by SubagentStart.
+
+    Args:
+        session_id: Hook session identifier (shared between PreToolUse and SubagentStart).
+        context: The full additionalContext string to inject into the subagent.
+        agent_type: The agent type (for logging/diagnostics).
+
+    Returns:
+        Path to the written cache file.
+    """
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Clean stale files first
+    _cleanup_stale_caches()
+
+    timestamp = int(time.time() * 1000)
+    cache_file = CACHE_DIR / f"{session_id}-{timestamp}.json"
+    payload = {
+        "context": context,
+        "agent_type": agent_type,
+        "timestamp": timestamp,
+    }
+
+    cache_file.write_text(json.dumps(payload))
+    logger.info(
+        "Cached context for session=%s agent=%s (%d bytes) -> %s",
+        session_id, agent_type, len(context), cache_file.name,
+    )
+    return cache_file
+
+
+def read_context_cache(session_id: str) -> Optional[dict]:
+    """Read and consume the most recent context cache for a session.
+
+    Returns the cache payload dict if found, or None if no cache exists.
+    The cache file is deleted after reading (one-shot consumption).
+
+    Args:
+        session_id: Hook session identifier.
+
+    Returns:
+        Dict with keys: context, agent_type, timestamp.  Or None.
+    """
+    if not CACHE_DIR.exists():
+        logger.debug("No cache directory found")
+        return None
+
+    # Find all cache files for this session, sorted by timestamp (newest first)
+    prefix = f"{session_id}-"
+    candidates = sorted(
+        [f for f in CACHE_DIR.iterdir() if f.name.startswith(prefix) and f.suffix == ".json"],
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+
+    if not candidates:
+        logger.debug("No cache files found for session=%s", session_id)
+        return None
+
+    cache_file = candidates[0]
+    try:
+        payload = json.loads(cache_file.read_text())
+        logger.info(
+            "Read context cache for session=%s agent=%s from %s",
+            session_id, payload.get("agent_type", "unknown"), cache_file.name,
+        )
+        # One-shot: delete after reading
+        cache_file.unlink(missing_ok=True)
+
+        # Clean up any older duplicates for this session
+        for stale in candidates[1:]:
+            stale.unlink(missing_ok=True)
+
+        return payload
+
+    except (json.JSONDecodeError, OSError) as exc:
+        logger.warning("Failed to read cache file %s: %s", cache_file, exc)
+        cache_file.unlink(missing_ok=True)
+        return None
+
+
+def _cleanup_stale_caches() -> None:
+    """Remove cache files older than CACHE_TTL_SECONDS."""
+    if not CACHE_DIR.exists():
+        return
+
+    cutoff = time.time() - CACHE_TTL_SECONDS
+    for f in CACHE_DIR.iterdir():
+        if f.suffix == ".json":
+            try:
+                if f.stat().st_mtime < cutoff:
+                    f.unlink(missing_ok=True)
+                    logger.debug("Cleaned stale cache: %s", f.name)
+            except OSError:
+                pass

package/hooks/modules/context/context_injector.py

@@ -1,8 +1,7 @@
 """Core context injection subsystem for project agents.
 
 Handles:
-- build_project_context: builds context string without mutating parameters (Phase 2)
-- inject_project_context: legacy wrapper that mutates parameters (backward compat)
+- build_project_context: builds context string for additionalContext injection
 - check_pending_updates_threshold: warns when pending updates accumulate
 - check_recent_critical_anomalies: surfaces critical anomalies from JSONL log
 - consume_anomaly_flag: reads and deletes anomaly signal flags
@@ -269,16 +268,6 @@ def build_project_context(
         logger.warning(f"No prompt provided for {subagent_type}, skipping context injection")
         return None, {}
 
-    # Deduplication guard: if context was already injected (e.g., by a
-    # previous hook or retry), do not inject again.  The "# Project Context"
-    # header is the canonical marker written by this function.
-    if "# Project Context" in prompt:
-        logger.warning(
-            "Duplicate context injection prevented for %s — prompt already "
-            "contains '# Project Context' header", subagent_type,
-        )
-        return None, {}
-
     try:
         # Find context_provider.py
         context_provider_paths = [
@@ -398,6 +387,23 @@ def build_project_context(
         if critical_summary:
             context_string += critical_summary
 
+        # Inject recent operational events (non-blocking)
+        try:
+            from ..events.event_writer import read_events
+            recent = read_events(hours=24, limit=20)
+            if recent:
+                lines = ["\n# Recent Events (last 24h)"]
+                for evt in recent:
+                    ts_short = evt.get("ts", "")[:16]
+                    etype = evt.get("type", "")
+                    agent_name = evt.get("agent", "")
+                    result_str = evt.get("result", "")
+                    label = f"{agent_name}: " if agent_name else ""
+                    lines.append(f"- [{ts_short}] {etype}: {label}{result_str}")
+                context_string += "\n".join(lines) + "\n"
+        except Exception as exc:
+            logger.debug("Event context injection failed (non-fatal): %s", exc)
+
         # Build telemetry snapshot
         telemetry = build_context_telemetry_snapshot(context_payload)
 
@@ -419,31 +425,3 @@ def build_project_context(
         return None, {}
 
 
-def inject_project_context(
-    parameters: dict,
-    project_agents: list,
-    hooks_dir: Path = None,
-) -> dict:
-    """
-    Legacy wrapper: inject project context by mutating parameters["prompt"].
-
-    Retained for backward compatibility (tests import this function).
-    New code should use build_project_context() with additionalContext instead.
-
-    Args:
-        parameters: Original Task tool parameters (will be mutated).
-        project_agents: List of valid project agent names.
-        hooks_dir: Path to the hooks directory.
-
-    Returns:
-        Modified parameters with context injected into prompt.
-    """
-    context_string, _telemetry = build_project_context(parameters, project_agents, hooks_dir)
-    if context_string is None:
-        return parameters
-
-    prompt = parameters.get("prompt", "")
-    enriched_prompt = f"# Task\n\n{prompt}\n{context_string}"
-    parameters["prompt"] = enriched_prompt
-
-    return parameters

package/hooks/modules/context/context_writer.py

@@ -14,7 +14,6 @@ Public API:
 
 import json
 import logging
-import re
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional
@@ -107,15 +106,6 @@ LEGACY_AGENT_CONTRACTS: Dict[str, List[str]] = {
 _contracts_cache: Dict[str, dict] = {}
 
 
-# ---------------------------------------------------------------------------
-# Known markers that terminate CONTEXT_UPDATE extraction
-# ---------------------------------------------------------------------------
-_KNOWN_MARKERS = re.compile(
-    r"^(?:AGENT_STATUS|CONTEXT_UPDATE|<!-- AGENT_STATUS):",
-    re.MULTILINE,
-)
-
-
 # ============================================================================
 # 1. parse_context_update
 # ============================================================================
@@ -334,7 +324,6 @@ def _merge_base_and_cloud(provider: str, config_dir: Path) -> dict:
     """
     base_file = config_dir / "context-contracts.json"
     cloud_file = config_dir / "cloud" / f"{provider}.json"
-    legacy_file = config_dir / f"context-contracts.{provider}.json"
 
     # Step 1: Load base contracts
     base_contracts = None
@@ -344,16 +333,7 @@ def _merge_base_and_cloud(provider: str, config_dir: Path) -> dict:
         except (json.JSONDecodeError, OSError) as exc:
             logger.warning("Failed to load base contracts from %s: %s", base_file, exc)
 
-    # Step 2: Fallback to legacy per-provider file
-    if base_contracts is None:
-        if legacy_file.exists():
-            try:
-                base_contracts = json.loads(legacy_file.read_text())
-                logger.info("Using legacy contracts from %s", legacy_file)
-            except (json.JSONDecodeError, OSError) as exc:
-                logger.warning("Failed to load legacy contracts from %s: %s", legacy_file, exc)
-
-    # Step 3: Final fallback to hardcoded LEGACY_AGENT_CONTRACTS
+    # Step 2: Final fallback to hardcoded LEGACY_AGENT_CONTRACTS
     if base_contracts is None:
         logger.warning("No contract files found in %s, using hardcoded legacy contracts", config_dir)
         return {
@@ -536,7 +516,3 @@ def process_context_updates(
     except Exception as e:
         logger.debug("Context update processing failed (non-fatal): %s", e)
         return None
-
-
-# Module-level alias for shorter import name
-update = process_context_updates

package/hooks/modules/context/contracts_loader.py

@@ -93,20 +93,17 @@ def build_context_update_reminder(
     for config_dir in config_dirs:
         if not config_dir.is_dir():
             continue
-        # Try new base+cloud system first
+        # Load base contracts
         base_file = config_dir / "context-contracts.json"
         cloud_file = config_dir / "cloud" / f"{cloud_provider}.json"
-        legacy_file = config_dir / f"context-contracts.{cloud_provider}.json"
 
         merged_agents = {}
-        for contract_file in [base_file, legacy_file]:
-            if contract_file.exists():
-                try:
-                    data = json.loads(contract_file.read_text())
-                    merged_agents = data.get("agents", {})
-                    break
-                except Exception:
-                    continue
+        if base_file.exists():
+            try:
+                data = json.loads(base_file.read_text())
+                merged_agents = data.get("agents", {})
+            except Exception:
+                pass
 
         # Merge cloud overrides
         if merged_agents and cloud_file.exists():

package/hooks/modules/core/hook_entry.py

@@ -20,6 +20,7 @@ Usage in a hook entrypoint::
     if __name__ == "__main__":
         run_hook(_handle, hook_name="stop_hook")
 """
+from __future__ import annotations
 
 import json
 import logging