@jaguilar87/gaia-ops 4.4.0 → 4.7.2

package/dist/gaia-ops/tools/context/surface_router.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""
+Surface routing and investigation brief generation.
+
+Provides deterministic surface classification for Gaia tasks using generic
+cross-repo surfaces instead of repo-specific routing tables.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    from ._paths import resolve_config_dir
+except ImportError:
+    from _paths import resolve_config_dir
+
+
+DEFAULT_SURFACE_ROUTING_FILE = "surface-routing.json"
+EVIDENCE_REPORT_FIELDS = [
+    "PATTERNS_CHECKED",
+    "FILES_CHECKED",
+    "COMMANDS_RUN",
+    "KEY_OUTPUTS",
+    "VERBATIM_OUTPUTS",
+    "CROSS_LAYER_IMPACTS",
+    "OPEN_GAPS",
+]
+# All fields including OWNERSHIP_ASSESSMENT (for investigation brief injection).
+# The runtime validator in response_contract.py separates OWNERSHIP_ASSESSMENT
+# for enum validation; its CONSOLIDATION_FIELDS list excludes it.
+CONSOLIDATION_REPORT_FIELDS = [
+    "OWNERSHIP_ASSESSMENT",
+    "CONFIRMED_FINDINGS",
+    "SUSPECTED_FINDINGS",
+    "CONFLICTS",
+    "OPEN_GAPS",
+    "NEXT_BEST_AGENT",
+]
+
+
+def _get_config_dir() -> Path:
+    """Resolve config directory from installed project or package checkout."""
+    return resolve_config_dir()
+
+
+def load_surface_routing_config(config_file: Optional[Path] = None) -> Dict[str, Any]:
+    """Load surface routing config. Returns empty config if missing or invalid."""
+    if config_file is None:
+        config_file = _get_config_dir() / DEFAULT_SURFACE_ROUTING_FILE
+
+    if not config_file.is_file():
+        return {"version": "missing", "reconnaissance_agent": "devops-developer", "surfaces": {}}
+
+    try:
+        return json.loads(config_file.read_text())
+    except Exception:
+        return {"version": "invalid", "reconnaissance_agent": "devops-developer", "surfaces": {}}
+
+
+@dataclass(frozen=True)
+class SurfaceMatch:
+    surface: str
+    score: float
+    matched_signals: List[str]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+def _normalize_text(text: str) -> str:
+    return " ".join((text or "").lower().split())
+
+
+def _score_surface(task_text: str, surface_name: str, surface_cfg: Dict[str, Any]) -> SurfaceMatch:
+    signals = surface_cfg.get("signals", {})
+    matched: List[str] = []
+    score = 0.0
+
+    for keyword in signals.get("keywords", []):
+        if keyword.lower() in task_text:
+            matched.append(keyword)
+            score += 1.0
+
+    for command in signals.get("commands", []):
+        if command.lower() in task_text:
+            matched.append(command)
+            score += 1.5
+
+    for artifact in signals.get("artifacts", []):
+        if artifact.lower() in task_text:
+            matched.append(artifact)
+            score += 1.0
+
+    # Small boost for explicit surface names.
+    if surface_name.lower() in task_text:
+        matched.append(surface_name)
+        score += 1.0
+
+    return SurfaceMatch(surface=surface_name, score=score, matched_signals=matched)
+
+
+def classify_surfaces(
+    task: str,
+    *,
+    current_agent: str = "",
+    routing_config: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Deterministically classify active surfaces for a task.
+
+    The classifier uses generic surface signals, not repo-specific topology.
+    """
+    config = routing_config or load_surface_routing_config()
+    surfaces_cfg = config.get("surfaces", {})
+    reconnaissance_agent = config.get("reconnaissance_agent", "devops-developer")
+    task_text = _normalize_text(task)
+
+    matches: List[SurfaceMatch] = []
+    for surface_name, surface_cfg in surfaces_cfg.items():
+        match = _score_surface(task_text, surface_name, surface_cfg)
+        if match.score > 0:
+            matches.append(match)
+
+    matches.sort(key=lambda item: item.score, reverse=True)
+
+    if matches:
+        top_score = matches[0].score
+        active_matches = [
+            match for match in matches
+            if match.score >= 1.0 and (match.score == top_score or match.score >= (top_score * 0.55))
+        ]
+    else:
+        active_matches = []
+
+    agent_to_surface = {
+        cfg.get("primary_agent", ""): surface_name
+        for surface_name, cfg in surfaces_cfg.items()
+    }
+    fallback_surface = agent_to_surface.get(current_agent, "")
+
+    if not active_matches and fallback_surface:
+        active_matches = [SurfaceMatch(surface=fallback_surface, score=0.2, matched_signals=["agent-fallback"])]
+
+    active_surfaces = [match.surface for match in active_matches]
+    match_map = {match.surface: match for match in active_matches}
+
+    if not active_surfaces:
+        return {
+            "active_surfaces": [],
+            "primary_surface": "",
+            "multi_surface": False,
+            "dispatch_mode": "reconnaissance",
+            "confidence": 0.0,
+            "recommended_agents": [reconnaissance_agent],
+            "matched_signals": {},
+            "reconnaissance_agent": reconnaissance_agent,
+        }
+
+    if current_agent in agent_to_surface and agent_to_surface[current_agent] in active_surfaces:
+        primary_surface = agent_to_surface[current_agent]
+    else:
+        primary_surface = active_surfaces[0]
+
+    recommended_agents = []
+    for surface_name in active_surfaces:
+        agent = surfaces_cfg.get(surface_name, {}).get("primary_agent", "")
+        if agent and agent not in recommended_agents:
+            recommended_agents.append(agent)
+
+    if len(active_surfaces) == 1:
+        dispatch_mode = "single_surface"
+    elif "planning_specs" in active_surfaces:
+        dispatch_mode = "sequential"
+    else:
+        dispatch_mode = "parallel"
+
+    confidence = round(min(1.0, sum(match.score for match in active_matches) / max(len(active_matches) * 3.0, 1.0)), 2)
+
+    return {
+        "active_surfaces": active_surfaces,
+        "primary_surface": primary_surface,
+        "multi_surface": len(active_surfaces) > 1,
+        "dispatch_mode": dispatch_mode,
+        "confidence": confidence,
+        "recommended_agents": recommended_agents or [reconnaissance_agent],
+        "matched_signals": {surface: match_map[surface].matched_signals for surface in active_surfaces},
+        "reconnaissance_agent": reconnaissance_agent,
+    }
+
+
+def build_investigation_brief(
+    task: str,
+    agent_name: str,
+    contract_context: Dict[str, Any],
+    *,
+    routing_config: Optional[Dict[str, Any]] = None,
+    routing: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Build a deterministic investigation brief for the current agent.
+    """
+    config = routing_config or load_surface_routing_config()
+    surfaces_cfg = config.get("surfaces", {})
+    if routing is None:
+        routing = classify_surfaces(task, current_agent=agent_name, routing_config=config)
+
+    primary_surface = routing.get("primary_surface", "")
+    primary_cfg = surfaces_cfg.get(primary_surface, {})
+    active_surfaces = routing.get("active_surfaces", [])
+    adjacent_surfaces = []
+    for surface_name in active_surfaces:
+        if surface_name != primary_surface and surface_name not in adjacent_surfaces:
+            adjacent_surfaces.append(surface_name)
+    for surface_name in primary_cfg.get("adjacent_surfaces", []):
+        if surface_name != primary_surface and surface_name not in adjacent_surfaces:
+            adjacent_surfaces.append(surface_name)
+
+    recommended_agents = routing.get("recommended_agents", [])
+    peer_agents = [agent for agent in recommended_agents if agent != agent_name]
+
+    agent_surface = ""
+    for surface_name, cfg in surfaces_cfg.items():
+        if cfg.get("primary_agent") == agent_name:
+            agent_surface = surface_name
+            break
+
+    if not active_surfaces:
+        role = "reconnaissance"
+    elif agent_surface == primary_surface:
+        role = "primary"
+    elif agent_surface in active_surfaces:
+        role = "cross_check"
+    else:
+        role = "adjacent"
+
+    cross_check_required = len(active_surfaces) > 1 or (agent_surface and agent_surface != primary_surface)
+
+    search_anchors = sorted(contract_context.keys())
+    required_checks = list(primary_cfg.get("required_checks", []))
+    for surface_name in adjacent_surfaces:
+        for check in surfaces_cfg.get(surface_name, {}).get("required_checks", []):
+            if check not in required_checks:
+                required_checks.append(check)
+
+    return {
+        "goal": task,
+        "agent_role": role,
+        "primary_surface": primary_surface,
+        "active_surfaces": active_surfaces,
+        "adjacent_surfaces": adjacent_surfaces,
+        "dispatch_mode": routing.get("dispatch_mode", "single_surface"),
+        "cross_check_required": cross_check_required,
+        "patterns_required": True,
+        "contract_sections_to_anchor": search_anchors,
+        "required_checks": required_checks,
+        "evidence_required": EVIDENCE_REPORT_FIELDS,
+        "consolidation_required": cross_check_required,
+        "consolidation_fields": CONSOLIDATION_REPORT_FIELDS if cross_check_required else [],
+        "recommended_peer_agents": peer_agents,
+        "stop_conditions": [
+            "Stop when additional files or commands only confirm the same conclusion without changing the decision.",
+            "Do not declare cross-surface work complete without filling CROSS_LAYER_IMPACTS and OPEN_GAPS.",
+            "If another surface owns the fix, name the next agent instead of guessing across domains.",
+        ],
+    }
+
+
+__all__ = [
+    "EVIDENCE_REPORT_FIELDS",
+    "CONSOLIDATION_REPORT_FIELDS",
+    "build_investigation_brief",
+    "classify_surfaces",
+    "load_surface_routing_config",
+]

package/dist/gaia-ops/tools/fast-queries/README.md

@@ -0,0 +1,65 @@
+# Fast-Queries: Quick Health Checks
+
+Optimized diagnostic scripts that provide instant health status in <5 seconds.
+Only shows problems, not everything.
+
+## Quick Usage
+
+```bash
+# Run all health checks
+.claude/tools/fast-queries/run_triage.sh
+
+# Run specific checks
+.claude/tools/fast-queries/run_triage.sh gitops    # Kubernetes/pods
+.claude/tools/fast-queries/run_triage.sh terraform # Terraform validation
+.claude/tools/fast-queries/run_triage.sh gcp       # GCP resources
+```
+
+## Available Scripts
+
+### 1. GitOps Health Check
+```bash
+.claude/tools/fast-queries/gitops/quicktriage_gitops_operator.sh [namespace]
+```
+**Output:** Only shows problematic pods, deployments not ready, and recent warnings.
+
+### 2. Terraform Validation
+```bash
+.claude/tools/fast-queries/terraform/quicktriage_terraform_architect.sh [directory]
+```
+**Output:** ✅/❌ for format, validation, and drift detection.
+
+### 3. GCP Resources Check
+```bash
+.claude/tools/fast-queries/cloud/gcp/quicktriage_gcp_troubleshooter.sh [project]
+```
+**Output:** Status of GKE clusters, Cloud SQL, recent errors, and quota warnings.
+
+## For Agents
+
+Add this to agent prompts for quick diagnostics:
+
+```bash
+# Instead of multiple kubectl/terraform/gcloud commands:
+bash .claude/tools/fast-queries/gitops/quicktriage_gitops_operator.sh namespace
+```
+
+## Output Format
+
+All scripts follow the same pattern:
+- ✅ = Healthy/OK
+- ❌ = Problem detected
+- ⚠️  = Warning/non-critical issue
+
+Exit codes:
+- 0 = All healthy
+- 1 = Issues found
+- 2 = Script error (missing tools)
+
+## Performance
+
+| Script | Duration | Focus |
+|--------|----------|-------|
+| GitOps | 2-3 sec | Pod/deployment health |
+| Terraform | 3-4 sec | Validation & drift |
+| GCP | 4-5 sec | Resource availability |

package/dist/gaia-ops/tools/fast-queries/__init__.py

@@ -0,0 +1,30 @@
+"""
+Fast-Queries Module: Agent diagnostic scripts
+
+This module provides quick diagnostic and health-check scripts for each Gaia-Ops agent.
+Scripts provide instant snapshots of system state without invoking the full orchestration workflow.
+
+Typical usage:
+    # Run all diagnostics via CLI
+    $ .claude/tools/fast-queries/run_triage.sh all
+
+    # Run specific agent
+    $ .claude/tools/fast-queries/run_triage.sh terraform
+
+Available agents:
+    - terraform: Terraform/Terragrunt validation
+    - gitops: Kubernetes/Flux/Helm snapshots
+    - gcp: GCP GKE/SQL/IAM diagnostics
+    - aws: AWS EKS/VPC/CloudWatch diagnostics
+    - devops: Application health & hygiene checks
+
+See README.md for detailed documentation.
+"""
+
+__version__ = "1.0.0"
+__all__ = [
+    "terraform",
+    "gitops",
+    "cloud",
+    "appservices",
+]

package/dist/gaia-ops/tools/fast-queries/appservices/quicktriage_devops_developer.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# QuickTriage script for DevOps Developer
+# Description: Quick health check for application services and development environment
+
+# Usage: quicktriage_devops_developer.sh [repo_path]
+
+set -euo pipefail
+
+REPO_PATH="${1:-.}"
+
+echo "=========================================="
+echo "DevOps Developer QuickTriage"
+echo "=========================================="
+echo "Repository: $REPO_PATH"
+echo "=========================================="
+echo ""
+
+# Change to repo directory
+cd "$REPO_PATH"
+
+# Check for common configuration files
+echo "### Configuration Files ###"
+for file in package.json docker-compose.yml Dockerfile .env.example Makefile; do
+    if [ -f "$file" ]; then
+        echo "[OK] $file exists"
+    else
+        echo "[--] $file not found"
+    fi
+done
+echo ""
+
+# Check git status
+echo "### Git Status ###"
+if [ -d ".git" ]; then
+    git status --short 2>/dev/null || echo "Git status failed"
+    echo ""
+    echo "Branch: $(git branch --show-current 2>/dev/null || echo 'unknown')"
+else
+    echo "Not a git repository"
+fi
+echo ""
+
+# Check for node modules (if package.json exists)
+if [ -f "package.json" ]; then
+    echo "### Node.js Project ###"
+    if [ -d "node_modules" ]; then
+        echo "[OK] node_modules present"
+    else
+        echo "[WARN] node_modules missing - run npm install"
+    fi
+    
+    # Check for common scripts
+    echo ""
+    echo "Available scripts:"
+    if command -v jq &> /dev/null; then
+        jq -r '.scripts | keys[]' package.json 2>/dev/null | head -10 || echo "Could not parse scripts"
+    else
+        grep -A20 '"scripts"' package.json 2>/dev/null | head -10 || echo "Could not read scripts"
+    fi
+    echo ""
+fi
+
+# Check Docker
+echo "### Docker Status ###"
+if command -v docker &> /dev/null; then
+    echo "[OK] Docker available"
+    docker info --format '{{.ContainersRunning}} containers running' 2>/dev/null || echo "Docker not accessible"
+else
+    echo "[--] Docker not installed"
+fi
+echo ""
+
+echo "=========================================="
+echo "QuickTriage Complete"
+echo "=========================================="

package/dist/gaia-ops/tools/fast-queries/cloud/aws/quicktriage_aws_troubleshooter.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# QuickTriage script for AWS Troubleshooter
+# Status: STANDBY - AWS agent not yet active
+
+# Description: Quick health check for AWS infrastructure
+# Usage: quicktriage_aws_troubleshooter.sh [profile] [region]
+# Note: This agent is currently in standby mode
+
+set -euo pipefail
+
+PROFILE="${1:-default}"
+REGION="${2:-us-east-1}"
+
+echo "=========================================="
+echo "AWS QuickTriage - Troubleshooter"
+echo "=========================================="
+echo "Profile: $PROFILE"
+echo "Region: $REGION"
+echo "Status: STANDBY"
+echo "=========================================="
+echo ""
+echo "AWS Troubleshooter is in standby mode."
+echo "Use GCP Troubleshooter for cloud diagnostics."
+echo ""
+echo "When activated, this script will check:"
+echo "  - EC2 instance status"
+echo "  - RDS database health"
+echo "  - EKS cluster status"
+echo "  - IAM role configurations"
+echo "  - CloudWatch alarms"
+echo ""
+echo "=========================================="

package/dist/gaia-ops/tools/fast-queries/cloud/gcp/quicktriage_gcp_troubleshooter.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# QuickTriage for GCP - Optimized version
+# Only shows critical resource status
+
+set -euo pipefail
+
+PROJECT="${GCP_PROJECT:-${1:-}}"
+CLUSTER="${GKE_CLUSTER:-${2:-}}"
+REGION="${GKE_REGION:-${3:-us-central1}}"
+
+# Get current project if not specified
+if [ -z "$PROJECT" ]; then
+    PROJECT=$(gcloud config get-value project 2>/dev/null || echo "")
+fi
+
+echo "=== GCP HEALTH CHECK: ${PROJECT:-no-project} ==="
+
+if ! command -v gcloud >/dev/null 2>&1; then
+    echo "❌ gcloud CLI not installed"
+    exit 2
+fi
+
+if [ -z "$PROJECT" ]; then
+    echo "❌ No GCP project configured"
+    echo "  Run: gcloud config set project PROJECT_ID"
+    exit 1
+fi
+
+# 1. GKE Clusters status (only if unhealthy)
+echo -n "GKE Clusters: "
+CLUSTERS=$(gcloud container clusters list --project="$PROJECT" --format="value(name,status)" 2>/dev/null || echo "")
+if [ -z "$CLUSTERS" ]; then
+    echo "⚠️  No clusters found"
+else
+    UNHEALTHY=$(echo "$CLUSTERS" | grep -v "RUNNING" || echo "")
+    if [ -n "$UNHEALTHY" ]; then
+        echo "❌ Issues detected"
+        echo "$UNHEALTHY" | awk '{printf "  - %s: %s\n", $1, $2}'
+    else
+        CLUSTER_COUNT=$(echo "$CLUSTERS" | wc -l)
+        echo "✅ $CLUSTER_COUNT cluster(s) running"
+    fi
+fi
+
+# 2. Cloud SQL status (only if issues)
+echo -n "Cloud SQL: "
+SQL_INSTANCES=$(gcloud sql instances list --project="$PROJECT" --format="value(name,state)" 2>/dev/null || echo "")
+if [ -z "$SQL_INSTANCES" ]; then
+    echo "⚠️  No instances found"
+else
+    SQL_DOWN=$(echo "$SQL_INSTANCES" | grep -v "RUNNABLE" || echo "")
+    if [ -n "$SQL_DOWN" ]; then
+        echo "❌ Issues detected"
+        echo "$SQL_DOWN" | awk '{printf "  - %s: %s\n", $1, $2}'
+    else
+        SQL_COUNT=$(echo "$SQL_INSTANCES" | wc -l)
+        echo "✅ $SQL_COUNT instance(s) running"
+    fi
+fi
+
+# 3. Recent errors (only critical)
+echo -n "Recent errors: "
+ERROR_COUNT=$(gcloud logging read "severity>=ERROR AND timestamp>=\"$(date -u -d '1 hour ago' '+%Y-%m-%dT%H:%M:%S')\"" \
+    --limit=10 --project="$PROJECT" --format="value(textPayload)" 2>/dev/null | wc -l || echo "0")
+
+if [ "$ERROR_COUNT" -gt 0 ]; then
+    echo "⚠️  $ERROR_COUNT errors in last hour"
+    # Show top 3 error sources
+    gcloud logging read "severity>=ERROR AND timestamp>=\"$(date -u -d '1 hour ago' '+%Y-%m-%dT%H:%M:%S')\"" \
+        --limit=10 --project="$PROJECT" --format="value(resource.labels.cluster_name,textPayload)" 2>/dev/null | \
+        head -3 | sed 's/^/  - /' || true
+else
+    echo "✅ No recent errors"
+fi
+
+# 4. Quota warnings (only if near limits)
+echo -n "Quota status: "
+QUOTA_ISSUES=$(gcloud compute project-info describe --project="$PROJECT" --format="value(quotas[].usage,quotas[].limit)" 2>/dev/null | \
+    awk '{if ($1/$2 > 0.8) print "High usage"}' | head -1 || echo "")
+
+if [ -n "$QUOTA_ISSUES" ]; then
+    echo "⚠️  Some quotas >80% used"
+else
+    echo "✅ All quotas healthy"
+fi
+
+# Exit code based on critical issues
+[ -n "$UNHEALTHY" ] || [ -n "$SQL_DOWN" ] && exit 1 || exit 0

package/dist/gaia-ops/tools/fast-queries/gitops/quicktriage_gitops_operator.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# QuickTriage for GitOps - Optimized version
+# Only shows problems, not everything
+
+set -euo pipefail
+
+NAMESPACE="${1:-tcm-non-prod}"
+
+echo "=== HEALTH CHECK: $NAMESPACE ==="
+
+# 1. Only problematic pods (not all pods)
+PROBLEM_PODS=$(kubectl get pods -n "$NAMESPACE" --no-headers 2>/dev/null | grep -v "Running\|Completed" || echo "")
+if [ -n "$PROBLEM_PODS" ]; then
+    echo "❌ PODS WITH ISSUES:"
+    echo "$PROBLEM_PODS" | awk '{printf "  - %s: %s (restarts: %s)\n", $1, $3, $4}'
+else
+    echo "✅ All pods healthy"
+fi
+
+# 2. Only deployments with missing replicas
+DEPLOY_ISSUES=$(kubectl get deploy -n "$NAMESPACE" --no-headers 2>/dev/null | awk '$2!=$3 {print $1, $2"/"$3}' || echo "")
+if [ -n "$DEPLOY_ISSUES" ]; then
+    echo "❌ DEPLOYMENTS NOT READY:"
+    echo "$DEPLOY_ISSUES" | awk '{printf "  - %s: %s replicas\n", $1, $2}'
+else
+    echo "✅ All deployments ready"
+fi
+
+# 3. HelmRelease summary (1 line)
+if command -v kubectl >/dev/null 2>&1 && kubectl api-resources | grep -q helmrelease 2>/dev/null; then
+    HR_COUNT=$(kubectl get helmrelease -n "$NAMESPACE" --no-headers 2>/dev/null | wc -l || echo "0")
+    HR_FAILED=$(kubectl get helmrelease -n "$NAMESPACE" --no-headers 2>/dev/null | grep -c False || echo "0")
+    if [ "$HR_FAILED" -gt 0 ]; then
+        echo "❌ HelmReleases: $HR_FAILED/$HR_COUNT failed"
+    elif [ "$HR_COUNT" -gt 0 ]; then
+        echo "✅ HelmReleases: $HR_COUNT healthy"
+    fi
+fi
+
+# 4. Recent warnings only (last 5)
+WARNINGS=$(kubectl get events -n "$NAMESPACE" --field-selector type=Warning --no-headers 2>/dev/null | tail -5 || echo "")
+if [ -n "$WARNINGS" ]; then
+    echo "⚠️  Recent warnings:"
+    echo "$WARNINGS" | awk '{print "  - " $5 ": " substr($0, index($0,$6))}'
+fi
+
+# Exit code based on issues
+[ -n "$PROBLEM_PODS" ] || [ -n "$DEPLOY_ISSUES" ] || [ "$HR_FAILED" -gt 0 ] && exit 1 || exit 0

package/dist/gaia-ops/tools/fast-queries/run_triage.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Fast-Queries Runner - Simplified version
+# Only runs the 3 essential triages
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SELECTED="${1:-all}"
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+run_script() {
+    local script="$1"
+    local name="$2"
+
+    echo -e "\n${YELLOW}Running $name...${NC}"
+
+    if [ ! -f "$script" ]; then
+        echo -e "${RED}✗ Script not found: $script${NC}"
+        return 1
+    fi
+
+    if bash "$script"; then
+        echo -e "${GREEN}✓ $name completed${NC}"
+        return 0
+    else
+        echo -e "${RED}✗ $name found issues${NC}"
+        return 1
+    fi
+}
+
+echo "=== FAST HEALTH CHECK ==="
+
+case "$SELECTED" in
+    all)
+        run_script "$SCRIPT_DIR/gitops/quicktriage_gitops_operator.sh" "GitOps"
+        run_script "$SCRIPT_DIR/terraform/quicktriage_terraform_architect.sh" "Terraform"
+        run_script "$SCRIPT_DIR/cloud/gcp/quicktriage_gcp_troubleshooter.sh" "GCP"
+        ;;
+    gitops|k8s|kubernetes)
+        run_script "$SCRIPT_DIR/gitops/quicktriage_gitops_operator.sh" "GitOps"
+        ;;
+    terraform|tf)
+        run_script "$SCRIPT_DIR/terraform/quicktriage_terraform_architect.sh" "Terraform"
+        ;;
+    gcp|cloud)
+        run_script "$SCRIPT_DIR/cloud/gcp/quicktriage_gcp_troubleshooter.sh" "GCP"
+        ;;
+    *)
+        echo "Usage: $0 [all|gitops|terraform|gcp]"
+        exit 1
+        ;;
+esac
+
+echo -e "\n${GREEN}Health check complete${NC}"