┌─────────────────────────────────────────────────────────────────┐
│                    ชั้นการกำกับดูแล                            │
├─────────────────────────────────────────────────────────────────┤
│ ชั้น 5: การกำกับดูแลทางธุรกิจ                                    │
│    - การอนุมัติกรณีใช้งาน การประเมินความเสี่ยง การตรวจสอบมูลค่า │
├─────────────────────────────────────────────────────────────────┤
│ ชั้น 4: ชั้นนโยบาย                                              │
│    - กฎ ข้อจำกัด การ์ดเรล นโยบายการปฏิบัติตามกฎระเบียบ         │
├─────────────────────────────────────────────────────────────────┤
│ ชั้น 3: ชั้นควบคุม                                              │
│    - การบังคับใช้ การตรวจสอบ ความสามารถในการแทรกแซง             │
├─────────────────────────────────────────────────────────────────┤
│ ชั้น 2: ความปลอดภัยระหว่างรัน                                   │
│    - การแยกกระบวนการ การแยกตัว การดำเนินการอย่างปลอดภัย         │
├─────────────────────────────────────────────────────────────────┤
│ ชั้น 1: ข้อมูลประจำตัวและการเข้าถึง                              │
│    - การตรวจสอบสิทธิ์ การอนุญาต การจัดการข้อมูลรับรอง            │
└─────────────────────────────────────────────────────────────────┘

# การกำหนดค่า Agent Zero-Trust
agent_identity:
  authentication:
    method: mTLS_with_JWT
    token_lifetime: 15m
    refresh_window: 5m
  
  authorization:
    model: RBAC_with_ABAC
    dynamic_scopes: true
    context_aware: true
  
  credential_rotation:
    frequency: 24h
    automatic: true
    grace_period: 5m

network_security:
  segmentation:
    agent_vlans: isolated
    egress_filtering: strict
    east_west_inspection: enabled
  
  mTLS:
    mutual_verification: required
    cert_pinning: enabled
    revocation_check: ocsp_stapling

นโยบายทั่วไป (ทั้งองค์กร)
    ↓
นโยบายโดเมน (การเงิน ทรัพยากรบุคคล วิศวกรรม)
    ↓
นโยบายเวิร์กโฟลว์ (ความสามารถของ Agent เฉพาะ)
    ↓
นโยบายระหว่างรัน (ข้อจำกัดเวลาดำเนินการ)

{
  "policy_id": "finance-agent-v1",
  "version": "1.2.0",
  "applies_to": ["agent:finance-*", "workflow:invoice-processing"],
  "rules": [
    {
      "name": "no_unapproved_transfers",
      "type": "action_block",
      "condition": "action.type == 'bank_transfer' && !action.approved_by",
      "effect": "DENY",
      "message": "การโอนเงินธนาคารต้องการการอนุมัติจากมนุษย์"
    },
    {
      "name": "pii_protection",
      "type": "data_filter",
      "condition": "data.contains_pii && destination.external",
      "effect": "REDACT",
      "message": "PII ถูกลบก่อนการส่งออก"
    },
    {
      "name": "spend_limits",
      "type": "quota",
      "condition": "monthly_spend > 1000",
      "effect": "ALERT_AND_QUEUE",
      "message": "ถึงวงเงินรายเดือนแล้ว รอการอนุมัติ"
    }
  ],
  "enforcement_mode": "ACTIVE",
  "audit_level": "FULL"
}

// มิดเดิลแวร์การบังคับใช้นโยบาย
async function enforcePolicy(context, action) {
  const policies = await loadApplicablePolicies(context.agent);
  
  for (const policy of policies) {
    const result = await evaluatePolicy(policy, context, action);
    
    if (result.effect === 'DENY') {
      await logPolicyViolation(context, action, policy);
      throw new PolicyViolationError(result.message);
    }
    
    if (result.effect === 'ALERT') {
      await notifyComplianceTeam(context, action, policy);
    }
  }
  
  return true; // ผ่านนโยบายทั้งหมด
}

# ตัวตกแต่งการตรวจสอบการดำเนินการ
@policy_monitored(policy_id="financial-workflow")
async def process_invoice(invoice_data):
    # ตรวจสอบนโยบายกลางการดำเนินการ
    await checkpoint_policy_check()
    
    # หากตรวจพบการละเมิดนโยบาย หยุดเพื่อตรวจสอบ
    if policy_state.requires_review:
        await request_human_approval()
    
    continue_processing()

# การกำหนดค่าท่อการตรวจสอบ
post_execution_audit:
  triggers:
    - workflow_complete
    - exception_raised
    - manual_review_requested
  
  analyzers:
    - pattern_detection
    - anomaly_scoring
    - compliance_validation
  
  actions:
    high_risk:
      - notify_security_team
      - create_incident_ticket
      - preserve_logs
    
    medium_risk:
      - add_to_review_queue
      - notify_manager
    
    low_risk:
      - log_only

service://agent/{domain}/{agent_name}/{instance_id}

ตัวอย่าง:
- service://agent/finance/invoice-processor/prod-001
- service://agent/support/ticket-classifier/prod-003
- service://agent/ops/system-monitor/prod-002

# การกำหนดบทบาท Agent
roles:
  invoice_processor:
    permissions:
      - read:erp:invoices
      - write:erp:invoice_status
      - execute:workflow:approval_request
    constraints:
      max_daily_operations: 1000
      allowed_hours: ["08:00-18:00"]
      allowed_regions: ["us-east-1", "eu-west-1"]
  
  customer_support_agent:
    permissions:
      - read:crm:customer_data
      - write:crm:tickets
      - execute:tool:email_send
    constraints:
      requires_human_oversight: true
      pii_access: redacted

# การประเมินนโยบาย ABAC
def evaluate_access(agent, resource, action, context):
    attributes = {
        'agent.clearance_level': agent.clearance,
        'agent.department': agent.department,
        'resource.classification': resource.classification,
        'resource.owner_department': resource.owner,
        'context.time_of_day': context.timestamp.hour,
        'context.risk_score': context.risk_score,
        'action.sensitivity': action.sensitivity
    }
    
    # นโยบาย: Agent สามารถเข้าถึงทรัพยากรในแผนกของตน
    # ระหว่างเวลาทำการ หากคะแนนความเสี่ยงต่ำ
    if (attributes['agent.department'] == attributes['resource.owner_department'] and
        9 <= attributes['context.time_of_day'] <= 17 and
        attributes['context.risk_score'] < 0.7):
        return AccessDecision.GRANT
    
    return AccessDecision.DENY

// บริการหมุนเวียนข้อมูลรับรอง
interface CredentialRotation {
  // สร้างข้อมูลรับรองใหม่
  async rotate(agentId: string): Promise<Credentials>;
  
  // การเปลี่ยนผ่านอย่างสง่างาม
  async transition(agentId: string, gracePeriod: number): Promise<void>;
  
  // การเพิกถอนฉุกเฉิน
  async revoke(agentId: string, reason: string): Promise<void>;
}

// การใช้งานพร้อมการหมุนเวียนอัตโนมัติ
class ManagedCredentials implements CredentialRotation {
  async rotate(agentId: string): Promise<Credentials> {
    const newCreds = await this.vault.generate(agentId, {
      ttl: '15m',           // อายุ 15 นาที
      renewable: true,      // สามารถต่ออายุได้ขณะใช้งาน
      max_ttl: '1h'         // บังคับหมุนเวียนหลัง 1 ชั่วโมง
    });
    
    // อัปเดต Agent ด้วยข้อมูลรับรองใหม่
    await this.agentManager.updateCredentials(agentId, newCreds);
    
    // กำหนดเวลาการหมุนเวียนครั้งต่อไป
    this.scheduler.schedule(`rotate-${agentId}`, '14m', () => {
      this.rotate(agentId);
    });
    
    return newCreds;
  }
}

# Kubernetes secret injection สำหรับ Agent
apiVersion: apps/v1
kind: Deployment
metadata:
  name: agent-processor
spec:
  template:
    spec:
      containers:
      - name: agent
        env:
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: agent-credentials
              key: api-key
        volumeMounts:
        - name: certs
          mountPath: /etc/agent/certs
          readOnly: true
      volumes:
      - name: certs
        csi:
          driver: secrets-store.csi.k8s.io
          readOnly: true
          volumeAttributes:
            secretProviderClass: agent-mtls-certs

# เมตริก Agent หลัก
AGENT_METRICS = {
    # เมตริกการดำเนินการ
    'agent_execution_duration': Histogram(
        'agent_execution_duration_seconds',
        'เวลาที่ใช้ในการดำเนินการเวิร์กโฟลว์ของ Agent',
        ['agent_type', 'workflow_id']
    ),
    'agent_steps_completed': Counter(
        'agent_steps_completed_total',
        'จำนวนขั้นตอนเวิร์กโฟลว์ที่เสร็จสมบูรณ์',
        ['agent_type', 'status']
    ),
    
    # เมตริก LLM
    'llm_tokens_used': Counter(
        'llm_tokens_used_total',
        'โทเค็นทั้งหมดที่ใช้โดยการเรียก LLM',
        ['model', 'agent_type']
    ),
    'llm_latency': Histogram(
        'llm_latency_seconds',
        'เวลาตอบสนอง API ของ LLM',
        ['model', 'operation']
    ),
    
    # เมตริกการใช้เครื่องมือ
    'tool_calls_total': Counter(
        'tool_calls_total',
        'การเรียกเครื่องมือทั้งหมด',
        ['tool_name', 'agent_type']
    ),
    'tool_error_rate': Gauge(
        'tool_error_rate',
        'เปอร์เซ็นต์ของการเรียกเครื่องมือที่ล้มเหลว',
        ['tool_name']
    ),
    
    # เมตริกต้นทุน
    'agent_cost_usd': Counter(
        'agent_cost_usd_total',
        'ต้นทุนการดำเนินการ Agent ทั้งหมด',
        ['agent_type', 'model']
    )
}

# เมตริกผลลัพธ์ทางธุรกิจ
BUSINESS_METRICS = {
    'tasks_completed': Counter(
        'business_tasks_completed_total',
        'งานที่เสร็จสมบูรณ์สำเร็จ',
        ['task_type', 'priority']
    ),
    'time_saved_minutes': Counter(
        'business_time_saved_minutes',
        'เวลาที่ประหยัดได้โดยประมาณจากระบบอัตโนมัติ',
        ['process_type']
    ),
    'human_escalations': Counter(
        'business_human_escalations_total',
        'กรณีที่ขยายไปยังมนุษย์',
        ['reason', 'urgency']
    ),
    'customer_satisfaction': Gauge(
        'business_csat_score',
        'คะแนนความพึงพอใจของลูกค้า',
        ['channel', 'agent_type']
    )
}

{
  "timestamp": "2026-06-28T09:45:32.123Z",
  "level": "INFO",
  "trace_id": "abc123-def456-ghi789",
  "span_id": "span123",
  "parent_span_id": "span000",
  "service": "agent-orchestrator",
  "agent": {
    "id": "finance-processor-001",
    "type": "invoice_automation",
    "version": "2.3.1"
  },
  "event": {
    "type": "tool_execution",
    "tool": "erp_api",
    "operation": "fetch_invoice",
    "status": "success",
    "duration_ms": 245
  },
  "context": {
    "workflow_id": "wf-invoice-12345",
    "user_id": "[email protected]",
    "tenant_id": "tenant-001"
  },
  "security": {
    "identity_verified": true,
    "permissions_checked": ["read:erp:invoices"],
    "data_classification": "internal"
  },
  "payload": {
    "invoice_id": "INV-2026-001",
    "amount": 5000.00,
    "currency": "USD"
  }
}

# การติดตามเวิร์กโฟลว์ Agent
from opentelemetry import trace
from opentelemetry.trace import Status, StatusCode

tracer = trace.get_tracer("agent.tracer")

class TracedAgent:
    async def execute_workflow(self, input_data):
        with tracer.start_as_current_span(
            name="agent_workflow",
            attributes={
                "agent.id": self.agent_id,
                "agent.type": self.agent_type,
                "workflow.input_size": len(input_data)
            }
        ) as workflow_span:
            try:
                # ขั้นตอนที่ 1: การตรวจสอบข้อมูล
                with tracer.start_span("step_validation") as validation_span:
                    validated_data = await self.validate(input_data)
                    validation_span.set_attribute("validation.errors", 0)
                
                # ขั้นตอนที่ 2: การให้เหตุผล LLM
                with tracer.start_span("llm_reasoning") as llm_span:
                    plan = await self.llm.generate_plan(validated_data)
                    llm_span.set_attribute("llm.tokens_input", plan.tokens_input)
                    llm_span.set_attribute("llm.tokens_output", plan.tokens_output)
                    llm_span.set_attribute("llm.model", plan.model)
                
                # ขั้นตอนที่ 3: การดำเนินการเครื่องมือ
                for idx, tool_call in enumerate(plan.tools):
                    with tracer.start_span(f"tool_{tool_call.name}") as tool_span:
                        tool_span.set_attribute("tool.name", tool_call.name)
                        tool_span.set_attribute("tool.args", str(tool_call.args))
                        
                        result = await self.execute_tool(tool_call)
                        
                        tool_span.set_attribute("tool.status", result.status)
                        tool_span.set_attribute("tool.duration_ms", result.duration)
                
                # ขั้นตอนที่ 4: การสร้างคำตอบ
                with tracer.start_span("generate_response") as response_span:
                    response = await self.generate_response(results)
                
                workflow_span.set_status(Status(StatusCode.OK))
                return response
                
            except Exception as e:
                workflow_span.set_status(
                    Status(StatusCode.ERROR, str(e))
                )
                workflow_span.record_exception(e)
                raise

# ส่งต่อบริบท trace ผ่านขอบเขต async
import contextvars

trace_context = contextvars.ContextVar('trace_context')

async def execute_subagent(parent_context, task):
    # ตั้งค่าบริบท trace สำหรับ subagent
    trace_context.set(parent_context)
    
    # Subagent สืบทอด trace ID ของ parent โดยอัตโนมัติ
    with tracer.start_span(
        name="subagent_execution",
        context=trace_context.get()
    ):
        return await subagent.execute(task)

# บันทึกการตรวจสอบที่ลงนามทางการเข้ารหัส
import hashlib
import json
from datetime import datetime

class ImmutableAuditLog:
    def __init__(self, storage_backend):
        self.storage = storage_backend
        self.previous_hash = self._get_last_hash()
    
    async def record_event(self, event: AuditEvent):
        # สร้างเหตุการณ์พร้อมข้อมูลเมตา
        audit_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "event_type": event.type,
            "event_data": event.data,
            "actor": event.actor,
            "resource": event.resource,
            "action": event.action,
            "result": event.result,
            "previous_hash": self.previous_hash,
            "sequence_number": await self._get_next_sequence()
        }
        
        # คำนวณ hash
        entry_json = json.dumps(audit_entry, sort_keys=True)
        entry_hash = hashlib.sha256(entry_json.encode()).hexdigest()
        audit_entry["hash"] = entry_hash
        
        # ลงนามด้วย HSM หากมี
        if self.hsm_available:
            audit_entry["signature"] = await self._sign_with_hsm(entry_hash)
        
        # จัดเก็บด้วยการรับประกัน write-once
        await self.storage.append(audit_entry)
        
        # อัปเดต chain
        self.previous_hash = entry_hash
        
        return entry_hash
    
    async def verify_integrity(self):
        """ตรวจสอบ chain การตรวจสอบทั้งหมด"""
        entries = await self.storage.read_all()
        
        for i, entry in enumerate(entries):
            # ตรวจสอบ hash chain
            if i > 0:
                expected_previous = entries[i-1]["hash"]
                if entry["previous_hash"] != expected_previous:
                    raise AuditIntegrityError(
                        f"Chain broken at entry {i}"
                    )
            
            # ตรวจสอบ entry hash
            entry_copy = {k: v for k, v in entry.items() if k != "hash"}
            expected_hash = hashlib.sha256(
                json.dumps(entry_copy, sort_keys=True).encode()
            ).hexdigest()
            
            if entry["hash"] != expected_hash:
                raise AuditIntegrityError(
                    f"Hash mismatch at entry {i}"
                )
        
        return True

# การตรวจจับการแก้ไขแบบเรียลไทม์
class TamperDetector:
    def __init__(self, audit_log, alert_service):
        self.audit = audit_log
        self.alerts = alert_service
        self.last_verified_hash = None
    
    async def continuous_verification(self):
        """งานพื้นหลังสำหรับการตรวจสอบความสมบูรณ์อย่างต่อเนื่อง"""
        while True:
            await asyncio.sleep(60)  # ตรวจสอบทุกนาที
            
            try:
                current_hash = await self.audit.get_latest_hash()
                
                if self.last_verified_hash and \
                   current_hash != self.last_verified_hash:
                    # ตรวจสอบว่านี่เป็นข้อมูลใหม่ที่ถูกต้องหรือไม่
                    is_valid = await self.audit.verify_integrity()
                    
                    if not is_valid:
                        await self.alerts.send_critical(
                            "AUDIT_TAMPER_DETECTED",
                            "การตรวจสอบความสมบูรณ์ของบันทึกการตรวจสอบล้มเหลว"
                        )
                
                self.last_verified_hash = current_hash
                
            except Exception as e:
                await self.alerts.send_critical(
                    "AUDIT_VERIFICATION_FAILED",
                    f"ข้อผิดพลาดการตรวจสอบ: {str(e)}"
                )

# schema เหตุการณ์การปฏิบัติตามกฎระเบียบ
events:
  AGENT_DEPLOYED:
    category: lifecycle
    retention: 7_years
    fields:
      - agent_id
      - agent_type
      - deployed_by
      - permissions_granted
      - approval_ticket
  
  POLICY_VIOLATION:
    category: security
    retention: 7_years
    fields:
      - policy_id
      - violation_type
      - agent_id
      - attempted_action
      - enforcement_result
      - remediation_action
  
  DATA_ACCESSED:
    category: data_governance
    retention: 3_years
    fields:
      - data_classification
      - access_purpose
      - agent_id
      - data_subject_id  # สำหรับ GDPR
      - legal_basis
  
  HUMAN_APPROVAL_REQUESTED:
    category: workflow
    retention: 5_years
    fields:
      - request_type
      - requested_by
      - approver
      - approval_deadline
      - escalation_path
  
  LLM_INVOCATION:
    category: ai_operations
    retention: 1_year
    fields:
      - model_provider
      - model_version
      - tokens_input
      - tokens_output
      - cost_usd
      - data_sent_externally
      - pii_detected

# ตัวสร้างรายงานการปฏิบัติตามกฎระเบียบ
class ComplianceReporter:
    def __init__(self, audit_log, event_store):
        self.audit = audit_log
        self.events = event_store
    
    async def generate_gdpr_report(
        self,
        data_subject_id: str,
        start_date: datetime,
        end_date: datetime
    ) -> GDPRReport:
        """สร้างรายงานการเข้าถึงข้อมูลของเจ้าของข้อมูล GDPR บทที่ 15"""
        
        # ค้นหาเหตุการณ์ทั้งหมดที่เกี่ยวข้องกับเจ้าของข้อมูลนี้
        events = await self.events.query({
            "data_subject_id": data_subject_id,
            "timestamp": {
                "$gte": start_date,
                "$lte": end_date
            }
        })
        
        report = GDPRReport(
            data_subject_id=data_subject_id,
            report_period=(start_date, end_date),
            generated_at=datetime.utcnow()
        )
        
        # จัดหมวดหมู่กิจกรรมการประมวลผล
        for event in events:
            if event.type == "DATA_ACCESSED":
                report.add_processing_activity(
                    purpose=event.access_purpose,
                    legal_basis=event.legal_basis,
                    data_categories=event.data_categories,
                    recipients=event.recipients,
                    retention_period=event.retention_period
                )
            
            elif event.type == "DATA_SHARED":
                report.add_third_party_disclosure(
                    recipient=event.recipient,
                    data_categories=event.data_categories,
                    legal_basis=event.legal_basis,
                    safeguards=event.safeguards
                )
        
        # คำนวณกรณีการตัดสินใจอัตโนมัติ
        automated_decisions = await self.events.count({
            "data_subject_id": data_subject_id,
            "type": "AUTOMATED_DECISION",
            "human_review": False
        })
        report.automated_decisions = automated_decisions
        
        return report
    
    async def generate_soc2_evidence(
        self,
        control_id: str,
        period: DateRange
    ) -> SOCTwoEvidence:
        """สร้างหลักฐานการควบคุม SOC 2 Type II"""
        
        evidence = SOCTwoEvidence(control_id=control_id)
        
        # CC6.1 - ความปลอดภัยการเข้าถึงเชิงตรรกะ
        if control_id == "CC6.1":
            access_events = await self.events.query({
                "type": {"$in": ["ACCESS_GRANTED", "ACCESS_REVOKED"]},
                "timestamp": {"$gte": period.start, "$lte": period.end}
            })
            evidence.add_samples(access_events)
            
            # เพิ่มหลักฐานการตรวจสอบการเข้าถึง
            reviews = await self.events.query({
                "type": "ACCESS_REVIEW_COMPLETED",
                "timestamp": {"$gte": period.start, "$lte": period.end}
            })
            evidence.add_samples(reviews)
        
        # CC7.1 - การตรวจสอบความปลอดภัย
        elif control_id == "CC7.1":
            monitoring_events = await self.events.query({
                "type": {"$in": ["THREAT_DETECTED", "ALERT_TRIGGERED"]},
                "timestamp": {"$gte": period.start, "$lte": period.end}
            })
            evidence.add_samples(monitoring_events)
        
        return evidence

# การจัดระดับความรุนแรงของ Alert
class AlertSeverity:
    CRITICAL = "critical"      # ต้องการการตอบสนองทันที
    HIGH = "high"              # ตอบสนองภายใน 15 นาที
    MEDIUM = "medium"          # ตอบสนองภายใน 1 ชั่วโมง
    LOW = "low"                # ตอบสนองภายใน 24 ชั่วโมง
    INFO = "info"              # บันทึกเท่านั้น ไม่ต้องดำเนินการ

# กฎการกำหนดเส้นทาง Alert
ALERT_ROUTING = {
    "policy_violation": {
        "critical": ["security_team", "compliance_officer"],
        "high": ["security_team"]
    },
    "anomaly_detected": {
        "critical": ["ml_team", "ops_team"],
        "high": ["ops_team"]
    },
    "cost_threshold": {
        "critical": ["finance_team", "cto"],
        "high": ["finance_team"]
    },
    "system_error": {
        "critical": ["ops_team", "on_call"],
        "high": ["ops_team"]
    }
}

# การลบข้อมูลซ้ำและการจัดกลุ่ม Alert
class AlertManager:
    def __init__(self):
        self.recent_alerts = TTLCache(maxsize=1000, ttl=300)
        self.alert_groups = {}
    
    async def process_alert(self, alert: Alert):
        # ตรวจสอบข้อมูลซ้ำ
        alert_key = self._generate_key(alert)
        if alert_key in self.recent_alerts:
            # เพิ่มตัวนับแทน Alert ใหม่
            await self._update_existing_alert(alert_key, alert)
            return
        
        # ตรวจสอบ Alert ที่เกี่ยวข้องเพื่อจัดกลุ่ม
        group_key = self._find_group_key(alert)
        if group_key:
            await self._add_to_group(group_key, alert)
            return
        
        # การจำกัดอัตรา
        if await self._is_rate_limited(alert.type):
            await self._queue_alert(alert)
            return
        
        # ส่ง Alert ใหม่
        await self._dispatch_alert(alert)
        self.recent_alerts[alert_key] = alert
    
    def _generate_key(self, alert: Alert) -> str:
        """สร้างคีย์ที่ไม่ซ้ำกันสำหรับการลบข้อมูลซ้ำ"""
        return hashlib.md5(
            f"{alert.type}:{alert.agent_id}:{alert.error_code}".encode()
        ).hexdigest()
    
    async def _dispatch_alert(self, alert: Alert):
        # กำหนดระดับความรุนแรง
        severity = self._classify_severity(alert)
        
        # รับกฎการกำหนดเส้นทาง
        recipients = ALERT_ROUTING.get(alert.type, {}).get(severity, [])
        
        # เสริมด้วยบริบท
        enriched_alert = await self._enrich_alert(alert)
        
        # ส่งผ่านช่องทางที่เหมาะสม
        for recipient in recipients:
            channel = self._get_channel(recipient)
            await channel.send(enriched_alert)

# ท่อข้อมูลแดชบอร์ดแบบเรียลไทม์
class DashboardPipeline:
    def __init__(self, websocket_manager):
        self.websocket = websocket_manager
        self.metrics_buffer = []
    
    async def stream_metrics(self):
        """สตรีมเมตริกแบบเรียลไทม์ไปยังแดชบอร์ด"""
        while True:
            metrics = await self._collect_current_metrics()
            
            dashboard_update = {
                "timestamp": datetime.utcnow().isoformat(),
                "agents": {
                    "active": metrics.active_agents,
                    "healthy": metrics.healthy_agents,
                    "degraded": metrics.degraded_agents,
                    "failed": metrics.failed_agents
                },
                "executions": {
                    "per_minute": metrics.executions_per_minute,
                    "success_rate": metrics.success_rate,
                    "avg_duration_ms": metrics.avg_duration
                },
                "costs": {
                    "hourly_usd": metrics.hourly_cost,
                    "projected_daily_usd": metrics.projected_daily_cost
                },
                "alerts": {
                    "critical": metrics.critical_alerts,
                    "open_incidents": metrics.open_incidents
                }
            }
            
            await self.websocket.broadcast("metrics", dashboard_update)
            await asyncio.sleep(5)  # อัปเดตทุก 5 วินาที
    
    async def _collect_current_metrics(self):
        """รวบรวมเมตริกระบบปัจจุบัน"""
        return AgentMetrics(
            active_agents=await self._count_active_agents(),
            healthy_agents=await self._count_healthy_agents(),
            executions_per_minute=await self._calculate_execution_rate(),
            hourly_cost=await self._calculate_hourly_cost(),
            critical_alerts=await self._count_critical_alerts()
        )

# ลำดับชั้นงบประมาณ Token
budgets:
  organization:
    daily_tokens: 10_000_000
    monthly_usd: 50_000
    alerts:
      - threshold: 80%
        notify: ["finance_team"]
      - threshold: 95%
        action: "throttle"
        notify: ["cto", "finance_team"]
  
  departments:
    engineering:
      daily_tokens: 4_000_000
      monthly_usd: 20_000
      
    support:
      daily_tokens: 3_000_000
      monthly_usd: 15_000
      
    marketing:
      daily_tokens: 2_000_000
      monthly_usd: 10_000
      
    operations:
      daily_tokens: 1_000_000
      monthly_usd: 5_000
  
  projects:
    invoice_automation:
      daily_tokens: 500_000
      model_tier: "standard"  # GPT-4o
      
    customer_chat:
      daily_tokens: 1_000_000
      model_tier: "fast"  # GPT-4o-mini
      
    code_review:
      daily_tokens: 200_000
      model_tier: "premium"  # GPT-5

# ตัวติดตามการใช้ Token
class TokenBudgetManager:
    def __init__(self, redis_client):
        self.redis = redis_client
        self.budgets = self._load_budgets()
    
    async def track_usage(
        self,
        agent_id: str,
        tokens_used: int,
        cost_usd: float,
        model: str
    ):
        """ติดตามการใช้ Token เทียบกับงบประมาณ"""
        
        timestamp = datetime.utcnow()
        
        # อัปเดตตัวนับ
        pipeline = self.redis.pipeline()
        
        # ตัวนับรายวัน
        daily_key = f"tokens:daily:{timestamp.strftime('%Y-%m-%d')}:{agent_id}"
        pipeline.incrby(daily_key, tokens_used)
        pipeline.expire(daily_key, 86400 * 2)  # เก็บไว้ 2 วัน
        
        # ตัวนับรายชั่วโมงสำหรับการจำกัดอัตรา
        hourly_key = f"tokens:hourly:{timestamp.strftime('%Y-%m-%d-%H')}:{agent_id}"
        pipeline.incrby(hourly_key, tokens_used)
        pipeline.expire(hourly_key, 7200)
        
        # การติดตามต้นทุน
        cost_key = f"cost:daily:{timestamp.strftime('%Y-%m')}"
        pipeline.incrbyfloat(cost_key, cost_usd)
        
        await pipeline.execute()
        
        # ตรวจสอบเกณฑ์งบประมาณ
        await self._check_budgets(agent_id, tokens_used)
    
    async def _check_budgets(self, agent_id: str, tokens_used: int):
        """ตรวจสอบว่าการใช้งานเกินเกณฑ์งบประมาณหรือไม่"""
        
        agent_budget = self.budgets.get_agent_budget(agent_id)
        current_usage = await self._get_current_usage(agent_id)
        
        utilization = current_usage / agent_budget.daily_tokens
        
        if utilization >= 0.95:
            await self._enforce_throttle(agent_id)
            await self._alert_budget_exceeded(agent_id, utilization)
        elif utilization >= 0.80:
            await self._alert_budget_warning(agent_id, utilization)
    
    async def can_execute(
        self,
        agent_id: str,
        estimated_tokens: int
    ) -> BudgetCheckResult:
        """ตรวจสอบว่าการดำเนินการได้รับอนุญาตภายใต้งบประมาณปัจจุบันหรือไม่"""
        
        agent_budget = self.budgets.get_agent_budget(agent_id)
        current_usage = await self._get_current_usage(agent_id)
        
        if current_usage + estimated_tokens > agent_budget.daily_tokens:
            return BudgetCheckResult(
                allowed=False,
                reason="เกินงบประมาณ Token รายวันแล้ว",
                current_usage=current_usage,
                budget_limit=agent_budget.daily_tokens
            )
        
        return BudgetCheckResult(allowed=True)

# การเลือกโมเดลแบบไดนามิกตามความซับซ้อนของงาน
class ModelRouter:
    def __init__(self):
        self.models = {
            "gpt-4o-mini": {"cost_per_1k": 0.0006, "capability": "basic"},
            "gpt-4o": {"cost_per_1k": 0.005, "capability": "advanced"},
            "gpt-5": {"cost_per_1k": 0.015, "capability": "expert"}
        }
    
    async def select_model(
        self,
        task: Task,
        required_quality: QualityLevel
    ) -> ModelSelection:
        """เลือกโมเดลที่เหมาะสมตามงานและความต้องการด้านคุณภาพ"""
        
        # วิเคราะห์ความซับซ้อนของงาน
        complexity = await self._analyze_complexity(task)
        
        # รับงบประมาณที่เหลืออยู่
        budget = await self._get_remaining_budget(task.agent_id)
        
        # การแลกเปลี่ยนคุณภาพ-ต้นทุน
        if required_quality == QualityLevel.MINIMUM:
            return ModelSelection(
                model="gpt-4o-mini",
                reasoning="ยอมรับคุณภาพขั้นต่ำ ประหยัดค่าใช้จ่ายสูงสุด"
            )
        
        elif required_quality == QualityLevel.BALANCED:
            if complexity < 0.5 and budget.utilization < 0.7:
                return ModelSelection(
                    model="gpt-4o-mini",
                    reasoning="งานความซับซ้อนต่ำ มีงบประมาณเหลือ"
                )
            else:
                return ModelSelection(
                    model="gpt-4o",
                    reasoning="ความซับซ้อนสูงกว่าต้องการโมเดลที่ดีกว่า"
                )
        
        elif required_quality == QualityLevel.MAXIMUM:
            return ModelSelection(
                model="gpt-5",
                reasoning="ต้องการคุณภาพสูงสุด"
            )

# ตัวแปรสภาพแวดล้อมความปลอดภัย n8n
environment:
  # การตรวจสอบสิทธิ์
  N8N_BASIC_AUTH_ACTIVE: "true"
  N8N_BASIC_AUTH_USER: "${N8N_ADMIN_USER}"
  N8N_BASIC_AUTH_PASSWORD: "${N8N_ADMIN_PASSWORD}"
  
  # ส่วนหัวความปลอดภัย
  N8N_SECURITY_HEADERS: "true"
  N8N_SECURITY_ACCESS_CONTROL_ALLOW_ORIGIN: "https://tropical-media.work"
  
  # การตั้งค่าการดำเนินการ
  N8N_EXECUTIONS_MODE: "queue"  # กระบวนการ worker แยกต่างหาก
  N8N_EXECUTIONS_TIMEOUT: "300"  # หมดเวลา 5 นาที
  N8N_EXECUTIONS_TIMEOUT_MAX: "7200"  # สูงสุด 2 ชั่วโมง
  
  # การบันทึกการตรวจสอบ
  N8N_LOG_OUTPUT: "file"
  N8N_LOG_FILE_LOCATION: "/var/log/n8n/"
  N8N_LOG_FILE_COUNT: "30"
  
  # ความปลอดภัยของข้อมูลรับรอง
  N8N_ENCRYPTION_KEY: "${N8N_ENCRYPTION_KEY}"
  
  # ข้อจำกัดเวิร์กโฟลว์
  N8N_BLOCK_ENV_ACCESS_IN_NODE: "true"
  N8N_NODE_ALLOW_LIST: ".n8n/nodes/allowed.json"

// Node ตรวจสอบการกำกับดูแล n8n
const policyService = require('./services/policyService');
const auditService = require('./services/auditService');

// การตรวจสอบนโยบายก่อนการดำเนินการ
async function execute() {
    const workflowContext = {
        workflowId: $workflow.id,
        executionId: $execution.id,
        userId: $execution.userId,
        nodes: $workflow.nodes
    };
    
    // ตรวจสอบว่าเวิร์กโฟลว์ได้รับอนุญาตให้ทำงานหรือไม่
    const policyCheck = await policyService.evaluateWorkflow(workflowContext);
    
    if (!policyCheck.allowed) {
        // บันทึกการละเมิดนโยบาย
        await auditService.logEvent({
            type: 'WORKFLOW_BLOCKED',
            workflowId: workflowContext.workflowId,
            reason: policyCheck.reason,
            violatedPolicies: policyCheck.violatedPolicies
        });
        
        return [{ 
            json: { 
                error: 'การดำเนินการเวิร์กโฟลว์ถูกบล็อกโดยนโยบาย',
                reason: policyCheck.reason 
            } 
        }];
    }
    
    // บันทึกการดำเนินการที่ได้รับอนุมัติ
    await auditService.logEvent({
        type: 'WORKFLOW_APPROVED',
        workflowId: workflowContext.workflowId,
        policiesChecked: policyCheck.checkedPolicies
    });
    
    return [{ json: { approved: true } }];
}

module.exports = { execute };

// Node เมตริกที่กำหนดเอง n8n
const prometheus = require('prom-client');

// กำหนดเมตริก
const workflowDuration = new prometheus.Histogram({
    name: 'n8n_workflow_duration_seconds',
    help: 'ระยะเวลาการดำเนินการเวิร์กโฟลว์',
    labelNames: ['workflow_id', 'status'],
    buckets: [0.1, 0.5, 1, 2, 5, 10, 30, 60]
});

const nodeExecutions = new prometheus.Counter({
    name: 'n8n_node_executions_total',
    help: 'การดำเนินการ node ทั้งหมด',
    labelNames: ['workflow_id', 'node_type', 'status']
});

async function execute() {
    const startTime = Date.now();
    const workflowId = $workflow.id;
    
    try {
        // ติดตามการดำเนินการ node
        nodeExecutions.inc({
            workflow_id: workflowId,
            node_type: 'custom_metrics',
            status: 'success'
        });
        
        // คำนวณและบันทึกระยะเวลา
        const duration = (Date.now() - startTime) / 1000;
        workflowDuration.observe(
            { workflow_id: workflowId, status: 'success' },
            duration
        );
        
        // เข้าสู่ Prometheus
        await prometheus.pushAdd({
            jobName: 'n8n-workflows',
            groupings: { workflow_id: workflowId }
        }, 'http://prometheus-pushgateway:9091');
        
        return [{ json: { metrics_pushed: true } }];
        
    } catch (error) {
        nodeExecutions.inc({
            workflow_id: workflowId,
            node_type: 'custom_metrics',
            status: 'error'
        });
        throw error;
    }
}

module.exports = { execute };

# การกำหนดค่าความปลอดภัย Agent OpenClaw
agent_security:
  authentication:
    require_approval_for:
      - external_api_calls
      - database_writes
      - file_system_access
      - email_sending
    
    mcp_server_security:
      verify_signatures: true
      allowed_origins:
        - "https://mcp.tropical-media.work"
        - "https://internal-mcp.local"
      
      rate_limits:
        requests_per_minute: 60
        burst_allowance: 10
  
  execution_sandbox:
    mode: "restricted"
    network_access: "outbound_only"
    file_system: "read_only"
    environment_variables: "whitelisted"
    
  audit:
    log_all_tool_calls: true
    log_llm_prompts: true
    log_reasoning: true
    retention_days: 90

# การผสานรวมการกำกับดูแล OpenClaw
from openclaw import Agent, PolicyEnforcer

class GovernedOpenClawAgent:
    def __init__(self, agent_config):
        self.agent = Agent(agent_config)
        self.policy_enforcer = PolicyEnforcer()
        self.audit_logger = AuditLogger()
    
    async def execute_with_governance(self, task):
        """ดำเนินการงาน Agent ด้วยการควบคุมการกำกับดูแบบเต็มรูปแบบ"""
        
        # สร้างบริบทการดำเนินการ
        context = ExecutionContext(
            agent_id=self.agent.id,
            user_id=task.user_id,
            session_id=task.session_id,
            timestamp=datetime.utcnow(),
            request_id=generate_uuid()
        )
        
        # การตรวจสอบนโยบายก่อนการดำเนินการ
        policy_result = await self.policy_enforcer.check(
            context=context,
            action=task.action,
            resources=task.resources
        )
        
        if not policy_result.allowed:
            await self.audit_logger.log_policy_violation(
                context=context,
                task=task,
                violation=policy_result
            )
            raise PolicyViolationError(policy_result.reason)
        
        # ดำเนินการด้วยการตรวจสอบ
        with self._create_span(context) as span:
            try:
                result = await self.agent.execute(task)
                
                # การตรวจสอบหลังการดำเนินการ
                await self.audit_logger.log_success(
                    context=context,
                    task=task,
                    result=result,
                    duration=span.duration
                )
                
                return result
                
            except Exception as e:
                await self.audit_logger.log_failure(
                    context=context,
                    task=task,
                    error=e
                )
                raise

# การตรวจสอบ Agent OpenClaw
class OpenClawMonitor:
    def __init__(self, metrics_collector):
        self.metrics = metrics_collector
    
    def instrument_agent(self, agent: Agent):
        """เพิ่มเครื่องมือการตรวจสอบไปยัง Agent OpenClaw"""
        
        # ห่อหุ้มการดำเนินการเครื่องมือ
        original_execute_tool = agent.execute_tool
        
        async def monitored_execute_tool(tool_name, params):
            start_time = time.time()
            
            try:
                result = await original_execute_tool(tool_name, params)
                
                # บันทึกเมตริกความสำเร็จ
                self.metrics.record_tool_execution(
                    tool=tool_name,
                    status="success",
                    duration=time.time() - start_time
                )
                
                return result
                
            except Exception as e:
                # บันทึกเมตริกความล้มเหลว
                self.metrics.record_tool_execution(
                    tool=tool_name,
                    status="error",
                    duration=time.time() - start_time,
                    error_type=type(e).__name__
                )
                raise
        
        agent.execute_tool = monitored_execute_tool
        
        # ห่อหุ้มการเรียก LLM
        original_llm_call = agent.llm.complete
        
        async def monitored_llm_call(prompt, **kwargs):
            start_time = time.time()
            
            result = await original_llm_call(prompt, **kwargs)
            
            # บันทึกเมตริก LLM
            self.metrics.record_llm_invocation(
                model=kwargs.get('model', 'default'),
                tokens_input=result.usage.prompt_tokens,
                tokens_output=result.usage.completion_tokens,
                duration=time.time() - start_time,
                cost=result.usage.total_cost
            )
            
            return result
        
        agent.llm.complete = monitored_llm_call
        
        return agent

┌─────────────────────────────────────────────────────────────────┐
│                    แดชบอร์ดการกำกับดูแล                         │
├─────────────────────────────────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │ สถานะสุขภาพ │  │ ภาพรวม      │  │ การติดตาม   │          │
│  │ Agent        │  │ Compliance   │  │ ต้นทุน      │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              กิจกรรมแบบเรียลไทม์                      │   │
│  │  • เวิร์กโฟลว์ที่ใช้งาน   • การดำเนินการปัจจุบัน        │   │
│  │  • แผนที่ความร้อนการใช้เครื่องมือ • ต้นทุน LLM ต่อชั่วโมง│   │
│  └─────────────────────────────────────────────────────────┘   │
├─────────────────────────────────────────────────────────────────┤
│  ┌───────────────────┐  ┌──────────────────────────────────┐   │
│  │   ALERTS          │  │   เหตุการณ์ AUDIT ล่าสุด          │   │
│  │  • วิกฤติ: 2     │  │  • การละเมิดนโยบาย - การเงิน    │   │
│  │  • สูง: 5         │  │  • การอนุญาตการเข้าถึง - DevOps │   │
│  │  • Incidents ที่เปิดอยู่ │  • เกินเกณฑ์ต้นทุน            │   │
│  └───────────────────┘  └──────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

# แบ็กเอนด์แดชบอร์ดการกำกับดูแบบ FastAPI
from fastapi import FastAPI, WebSocket
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI(title="แดชบอร์ดการกำกับดูแล AI")

# CORS สำหรับการเข้าถึงแดชบอร์ด
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://governance.tropical-media.work"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# จุดสิ้นสุดข้อมูลแดชบอร์ด
@app.get("/api/dashboard/overview")
async def get_dashboard_overview():
    """รับเมตริกแดชบอร์ดระดับสูง"""
    return {
        "agents": {
            "total": await agent_registry.count(),
            "healthy": await health_checker.count_healthy(),
            "degraded": await health_checker.count_degraded(),
            "failed": await health_checker.count_failed()
        },
        "executions": {
            "last_hour": await execution_store.count_last_hour(),
            "success_rate": await execution_store.calculate_success_rate(),
            "avg_duration_ms": await execution_store.avg_duration()
        },
        "compliance": {
            "overall_score": await compliance_calculator.score(),
            "open_findings": await compliance_store.count_open_findings(),
            "last_audit": await audit_log.last_audit_date()
        },
        "costs": {
            "today_usd": await cost_tracker.today(),
            "mtd_usd": await cost_tracker.month_to_date(),
            "projected_month_usd": await cost_tracker.projected_month()
        }
    }

@app.get("/api/agents/{agent_id}/details")
async def get_agent_details(agent_id: str):
    """รับข้อมูลโดยละเอียดเกี่ยวกับ Agent เฉพาะ"""
    agent = await agent_registry.get(agent_id)
    
    return {
        "metadata": agent.metadata,
        "health": await health_checker.check(agent_id),
        "recent_executions": await execution_store.recent(agent_id, limit=20),
        "cost_breakdown": await cost_tracker.breakdown(agent_id),
        "compliance_status": await compliance_calculator.agent_score(agent_id),
        "policy_violations": await audit_log.violations(agent_id, days=30)
    }

@app.websocket("/ws/realtime")
async def realtime_websocket(websocket: WebSocket):
    """WebSocket สำหรับการอัปเดตแดชบอร์ดแบบเรียลไทม์"""
    await websocket.accept()
    
    try:
        while True:
            # รวบรวมเมตริกแบบเรียลไทม์
            update = {
                "timestamp": datetime.utcnow().isoformat(),
                "active_executions": await execution_store.active_count(),
                "current_throughput": await metrics_collector.current_tps(),
                "alerts": await alert_manager.recent(5)
            }
            
            await websocket.send_json(update)
            await asyncio.sleep(5)
            
    except Exception:
        await websocket.close()

# จุดสิ้นสุดการค้นหาบันทึกการตรวจสอบ
@app.get("/api/audit/search")
async def search_audit_logs(
    start_date: datetime,
    end_date: datetime,
    event_type: Optional[str] = None,
    agent_id: Optional[str] = None,
    severity: Optional[str] = None,
    limit: int = 100
):
    """ค้นหาและกรองบันทึกการตรวจสอบ"""
    query = AuditQuery(
        start_date=start_date,
        end_date=end_date,
        event_type=event_type,
        agent_id=agent_id,
        severity=severity,
        limit=limit
    )
    
    results = await audit_log.search(query)
    return {"results": results, "total": len(results)}

# การใช้ SOC 2 Common Criteria
soc2_controls:
  CC6.1:  # ความปลอดภัยการเข้าถึงเชิงตรรกะ
    implementations:
      - name: "การจัดการข้อมูลประจำตัว Agent"
        description: "Agent ทั้งหมดมี Service Identity ที่ไม่ซ้ำกัน"
        evidence_sources:
          - agent_registry
          - identity_provider
        
      - name: "การควบคุมการเข้าถึงตามบทบาท"
        description: "RBAC บังคับใช้สำหรับการดำเนินการ Agent ทั้งหมด"
        evidence_sources:
          - policy_engine
          - access_control_logs
    
  CC6.2:  # ก่อนการเข้าถึง
    implementations:
      - name: "การตรวจสอบนโยบายก่อนการดำเนินการ"
        description: "การกระทำ Agent ทั้งหมดได้รับการตรวจสอบก่อนการดำเนินการ"
        evidence_sources:
          - policy_enforcement_logs
          - approval_workflows
  
  CC7.1:  # การตรวจสอบความปลอดภัย
    implementations:
      - name: "การตรวจสอบ Agent แบบเรียลไทม์"
        description: "การตรวจสอบพฤติกรรม Agent อย่างต่อเนื่อง"
        evidence_sources:
          - metrics_collector
          - alert_manager
      
      - name: "การตรวจจับความผิดปกติ"
        description: "การตรวจจับพฤติกรรม Agent ที่ผิดปกติด้วย ML"
        evidence_sources:
          - anomaly_detector
          - incident_response_logs
  
  CC7.2:  # การตรวจจับเหตุการณ์
    implementations:
      - name: "การแจ้งเตือนอัตโนมัติ"
        description: "การแจ้งเตือนแบบเรียลไทม์สำหรับเหตุการณ์ความปลอดภัย"
        evidence_sources:
          - alert_manager
          - notification_logs
  
  A1.2:  # ความพร้อมใช้งาน
    implementations:
      - name: "การตรวจสอบสุขภาพ Agent"
        description: "การตรวจสอบสุขภาพและการ fail over อย่างต่อเนื่อง"
        evidence_sources:
          - health_checker
          - uptime_metrics

# การรวบรวมหลักฐาน SOC 2 แบบอัตโนมัติ
class SOC2EvidenceCollector:
    def __init__(self):
        self.evidence_store = EvidenceStore()
    
    async def collect_cc61_evidence(self, period: DateRange):
        """รวบรวมหลักฐานสำหรับ CC6.1 - การเข้าถึงเชิงตรรกะ"""
        
        evidence = {
            "control": "CC6.1",
            "period": period,
            "collected_at": datetime.utcnow(),
            "samples": []
        }
        
        # Sample 1: การกำหนดค่าข้อมูลประจำตัว Agent
        agent_configs = await self._sample_agent_configs(period, n=50)
        evidence["samples"].append({
            "type": "agent_identities",
            "description": "การกำหนดค่า Service Identity สำหรับ Agent",
            "data": agent_configs,
            "count": len(agent_configs)
        })
        
        # Sample 2: การตัดสินใจการควบคุมการเข้าถึง
        access_decisions = await self._sample_access_decisions(period, n=100)
        evidence["samples"].append({
            "type": "access_control_logs",
            "description": "การบันทึกการตัดสินใจด้านการอนุญาต",
            "data": access_decisions,
            "count": len(access_decisions)
        })
        
        # Sample 3: หลักฐานการหมุนเวียนข้อมูลรับรอง
        credential_rotations = await self._get_credential_rotations(period)
        evidence["samples"].append({
            "type": "credential_rotations",
            "description": "เหตุการณ์การหมุนเวียนข้อมูลรับรองอัตโนมัติ",
            "data": credential_rotations,
            "count": len(credential_rotations)
        })
        
        await self.evidence_store.store(evidence)
        return evidence

# การใช้สิทธิเจ้าของข้อมูล GDPR
class GDPRAgentCompliance:
    def __init__(self, data_inventory, audit_log):
        self.data_inventory = data_inventory
        self.audit = audit_log
    
    async def handle_access_request(
        self,
        data_subject_id: str
    ) -> DataSubjectAccessReport:
        """จัดการคำขอการเข้าถึง GDPR บทที่ 15"""
        
        # ระบุข้อมูลทั้งหมดที่เกี่ยวข้องกับเจ้าของข้อมูลนี้
        data_locations = await self.data_inventory.find_by_subject(
            data_subject_id
        )
        
        report = DataSubjectAccessReport(
            subject_id=data_subject_id,
            request_date=datetime.utcnow()
        )
        
        for location in data_locations:
            # รวบรวมข้อมูลจากแต่ละระบบ
            data = await self._collect_from_location(location, data_subject_id)
            report.add_data_source(location, data)
            
            # บันทึกการรวบรวมสำหรับการตรวจสอบ
            await self.audit.log_event({
                "type": "GDPR_DATA_ACCESSED",
                "data_subject_id": data_subject_id,
                "system": location.system,
                "purpose": "access_request",
                "legal_basis": "GDPR_Article_15"
            })
        
        return report
    
    async def handle_deletion_request(
        self,
        data_subject_id: str
    ) -> DeletionConfirmation:
        """จัด handling คำขอการลบ GDPR บทที่ 17"""
        
        deletion_report = DeletionConfirmation(
            subject_id=data_subject_id,
            initiated_at=datetime.utcnow()
        )
        
        # ค้นหาตำแหน่งข้อมูลทั้งหมด
        locations = await self.data_inventory.find_by_subject(data_subject_id)
        
        for location in locations:
            try:
                # พยายามลบ
                result = await self._delete_from_location(
                    location,
                    data_subject_id
                )
                
                deletion_report.add_success(location, result)
                
            except Exception as e:
                # บันทึกความล้มเหลว อาจต้องตรวจสอบด้วยตนเอง
                deletion_report.add_failure(location, str(e))
        
        # ส่งไปยังหน่วยความจำ Agent
        await self._purge_from_agent_memory(data_subject_id)
        
        # บันทึกการเสร็จสมบูรณ์
        await self.audit.log_event({
            "type": "GDPR_DELETION_COMPLETED",
            "data_subject_id": data_subject_id,
            "systems_affected": len(locations),
            "timestamp": datetime.utcnow()
        })
        
        return deletion_report
    
    async def _purge_from_agent_memory(self, data_subject_id: str):
        """ลบข้อมูลเจ้าของข้อมูลออกจากระบบหน่วยความจำ Agent"""
        
        # ตรวจสอบหน่วยความจำทั้งหมด
        memory_stores = [
            "conversation_memory",
            "vector_store",
            "episodic_memory",
            "semantic_memory"
        ]
        
        for store in memory_stores:
            entries = await self._find_in_memory(store, data_subject_id)
            
            for entry in entries:
                await self._redact_memory_entry(store, entry)
                
                await self.audit.log_event({
                    "type": "MEMORY_REDACTED",
                    "data_subject_id": data_subject_id,
                    "memory_store": store,
                    "entry_id": entry.id
                })

# การจัดประเภทเหตุการณ์ AI Agent
class IncidentClassifier:
    SEVERITY_MATRIX = {
        # (impact, urgency) -> severity
        ("high", "immediate"): "CRITICAL",
        ("high", "high"): "HIGH",
        ("medium", "immediate"): "HIGH",
        ("high", "medium"): "MEDIUM",
        ("medium", "high"): "MEDIUM",
        ("low", "immediate"): "MEDIUM",
        ("medium", "medium"): "LOW",
        ("low", "high"): "LOW",
        ("low", "medium"): "INFO",
    }
    
    def classify(self, incident: AgentIncident) -> IncidentClassification:
        """จัดระดับความรุนแรงของเหตุการณ์ Agent"""
        
        # กำหนดผลกระทบ
        impact = self._assess_impact(incident)
        
        # กำหนดความเร่งด่วน
        urgency = self._assess_urgency(incident)
        
        # รับระดับความรุนแรง
        severity = self.SEVERITY_MATRIX.get(
            (impact, urgency),
            "LOW"
        )
        
        return IncidentClassification(
            severity=severity,
            impact=impact,
            urgency=urgency,
            recommended_response_time=self._response_time(severity)
        )
    
    def _assess_impact(self, incident: AgentIncident) -> str:
        """ประเมินผลกระทบทางธุรกิจของเหตุการณ์"""
        
        # ตรวจสอบตัวบ่งชี้การละเมิดข้อมูล
        if incident.type in ["DATA_EXFILTRATION", "UNAUTHORIZED_ACCESS"]:
            if incident.data_classification == "confidential":
                return "high"
        
        # ตรวจสอบผลกระทบทางการเงิน
        if incident.estimated_cost_usd and incident.estimated_cost_usd > 10000:
            return "high"
        
        # ตรวจสอบผลกระทบด้านการดำเนินงาน
        if incident.affected_agents and len(incident.affected_agents) > 10:
            return "high"
        
        if incident.workflow_downtime_minutes and incident.workflow_downtime_minutes > 30:
            return "medium"
        
        return "low"

# Playbooks การตอบสนองต่อเหตุการณ์
playbooks:
  policy_violation_detected:
    triggers:
      - event: POLICY_VIOLATION
        severity: [high, critical]
    
    steps:
      - action: isolate_agent
        description: "แยก Agent ที่ละเมิดทันที"
        timeout: 30s
      
      - action: preserve_logs
        description: "จับภาพและรักษาบันทึกที่เกี่ยวข้องทั้งหมด"
        timeout: 60s
      
      - action: notify_security
        description: "แจ้งทีมความปลอดภัย"
        channels: [slack, pagerduty]
      
      - action: create_incident_ticket
        description: "สร้างตั๋วติดตาม"
        system: jira
      
      - action: await_human_review
        description: "หยุดรอการตรวจสอบของมนุษย์"
        condition: severity == "critical"
  
  anomalous_cost_spike:
    triggers:
      - event: COST_THRESHOLD_EXCEEDED
        threshold_percent: 200
    
    steps:
      - action: throttle_agent
        description: "ลดอัตราการดำเนินการ Agent"
        rate_limit: "10%"
      
      - action: analyze_spike
        description: "ระบุสาเหตุของการเพิ่มขึ้นของต้นทุน"
        timeout: 5m
      
      - action: notify_finance
        description: "แจ้งทีมการเงิน"
        
      - action: conditional_escalate
        description: "ขยายหาก >$1000 เกินงบประมาณ"
        condition: overage_usd > 1000
  
  agent_loop_detected:
    triggers:
      - event: INFINITE_LOOP_DETECTED
    
    steps:
      - action: terminate_execution
        description: "ยุติเวิร์กโฟลว์ที่ looping"
        force: true
      
      - action: capture_state
        description: "รักษาสถานะการดำเนินการสำหรับการแก้ไขข้อบกพร่อง"
      
      - action: alert_engineering
        description: "แจ้งทีมวิศวกรรม"
      
      - action: block_temporarily
        description: "บล็อก Agent จนกว่าจะแก้ไข"
        duration: "1h"

# การตอบสนองต่อเหตุการณ์แบบอัตโนมัติ
class IncidentResponder:
    def __init__(self):
        self.playbooks = self._load_playbooks()
        self.orchestrator = ResponseOrchestrator()
    
    async def handle_incident(self, incident: AgentIncident):
        """ตอบสนองต่อเหตุการณ์ Agent โดยอัตโนมัติ"""
        
        # จัดประเภทเหตุการณ์
        classification = self.classifier.classify(incident)
        
        # เลือก Playbook ที่เหมาะสม
        playbook = self._select_playbook(incident, classification)
        
        if not playbook:
            # ไม่มีการตอบสนองอัตโนมัติ ขยายไปยังมนุษย์
            await self._escalate_to_human(incident, classification)
            return
        
        # ดำเนินการ Playbook
        execution_context = {
            "incident": incident,
            "classification": classification,
            "start_time": datetime.utcnow()
        }
        
        for step in playbook.steps:
            try:
                result = await self._execute_step(step, execution_context)
                
                if step.condition and not self._evaluate_condition(
                    step.condition,
                    execution_context
                ):
                    continue
                
                # บันทึกการดำเนินการขั้นตอน
                await self._log_step(incident, step, result)
                
            except Exception as e:
                # ขั้นตอนล้มเหลว ขยาย
                await self._escalate_step_failure(incident, step, e)
                break
        
        # อัปเดตสถานะเหตุการณ์
        await self._update_incident_status(incident, "responded")
    
    async def _execute_step(
        self,
        step: PlaybookStep,
        context: Dict
    ) -> StepResult:
        """ดำเนินการขั้นตอนการตอบสนองเดียว"""
        
        action_handlers = {
            "isolate_agent": self._isolate_agent,
            "preserve_logs": self._preserve_logs,
            "notify_security": self._notify_security,
            "throttle_agent": self._throttle_agent,
            "terminate_execution": self._terminate_execution
        }
        
        handler = action_handlers.get(step.action)
        if not handler:
            raise ValueError(f"การกระทำที่ไม่รู้จัก: {step.action}")
        
        return await handler(context, step.parameters)

# การตรวจจับและป้องกัน Prompt Injection
class PromptInjectionGuard:
    def __init__(self):
        self.classifier = self._load_injection_classifier()
        self.content_filter = ContentFilter()
    
    async def validate_input(self, user_input: str) -> ValidationResult:
        """ตรวจสอบข้อมูลนำเข้าของผู้ใช้สำหรับความพยายาม Prompt Injection"""
        
        # การจัดประเภทแบบ ML
        injection_score = await self.classifier.score(user_input)
        
        if injection_score > 0.8:
            return ValidationResult(
                valid=False,
                reason:"ตรวจพบ Prompt Injection ด้วยความมั่นใจสูง",
                confidence=injection_score,
                action="BLOCK"
            )
        
        if injection_score > 0.5:
            return ValidationResult(
                valid=False,
                reason:"รูปแบบข้อมูลนำเข้าที่น่าสงสัย",
                confidence=injection_score,
                action="REQUIRE_REVIEW"
            )
        
        # การตรวจสอบเชิงปฏิบัติเพิ่มเติม
        heuristics_result = self._check_heuristics(user_input)
        if heuristics_result.suspicious:
            return ValidationResult(
                valid=False,
                reason=heuristics_result.reason,
                action="REQUIRE_REVIEW"
            )
        
        return ValidationResult(valid=True)
    
    def _check_heuristics(self, text: str) -> HeuristicResult:
        """ใช้การตรวจสอบเชิงปฏิบัติสำหรับรูปแบบ Injection"""
        
        patterns = [
            r"ignore (previous|above|earlier)",  # การเขียนทับคำสั่ง
            r"system(?: prompt)?[:\s]*",  # การเข้าถึง system prompt
            r"you are now.*?:",  # การปรับเปลี่ยนบทบาท
            r"\{\{.*system.*\}\}",  # Template injection
            r"new instructions?:",  # การฉีดคำสั่ง
            r"disregard (all|previous).*constraint",  # การหลีกเลี่ยงข้อจำกัด
        ]
        
        for pattern in patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return HeuristicResult(
                    suspicious=True,
                    reason=f"รูปแบบตรงกับ: {pattern}"
                )
        
        return HeuristicResult(suspicious=False)

# การ Sanitization เอาท์พุต Agent
class OutputSanitizer:
    def __init__(self):
        self.pii_detector = PIIDetector()
        self.code_validator = CodeValidator()
    
    async def sanitize(
        self,
        agent_output: str,
        output_type: str,
        destination: str
    ) -> SanitizationResult:
        """Sanitization เอาท์พุต Agent ก่อนการใช้งาน"""
        
        sanitized = agent_output
        actions_taken = []
        
        # ตรวจหา PII
        pii_findings = await self.pii_detector.scan(sanitized)
        if pii_findings:
            if destination == "external":
                # Redact PII สำหรับปลายทางภายนอก
                sanitized = await self._redact_pii(sanitized, pii_findings)
                actions_taken.append(f"ลบ {len(pii_findings)} อินสแตนซ์ PII")
            else:
                actions_taken.append(
                    f"คำเตือน: พบ {len(pii_findings)} อินสแตนซ์ PII"
                )
        
        # ตรวจสอบรหัสหากมี
        if output_type == "code":
            code_validation = await self.code_validator.validate(sanitized)
            if not code_validation.safe:
                return SanitizationResult(
                    safe=False,
                    reason=f"ตรวจพบรหัสที่ไม่ปลอดภัย: {code_validation.issues}",
                    output=None
                )
        
        # ตรวจหารูปแบบ Injection ในเอาท์พุต
        if self._contains_injection_patterns(sanitized):
            return SanitizationResult(
                safe=False,
                reason="เอาท์พุตมีรูปแบบ Injection ที่อาจเป็นไปได้",
                output=None
            )
        
        return SanitizationResult(
            safe=True,
            output=sanitized,
            actions_taken=actions_taken
        )

# Blue-Green Agent Deployment
deployment:
  strategy: blue_green
  
  blue:
    version: "2.3.1"
    traffic_percent: 100
    agent_pool:
      replicas: 5
      resources:
        cpu: "2"
        memory: "4Gi"
    
  green:
    version: "2.4.0"
    traffic_percent: 0
    agent_pool:
      replicas: 5
      resources:
        cpu: "2"
        memory: "4Gi"
  
  promotion:
    health_checks:
      - metric: error_rate
        threshold: "< 0.01"
        duration: 5m
      - metric: latency_p99
        threshold: "< 500ms"
        duration: 5m
    
    canary_steps:
      - traffic: 5
        duration: 10m
      - traffic: 25
        duration: 15m
      - traffic: 50
        duration: 15m
      - traffic: 100
        duration: 0
  
  rollback:
    automatic_on:
      - error_rate > 0.05
      - latency_p99 > 2000ms
      - policy_violations > 0

# ผู้ประสานงานการปรับใช้ Agent
class AgentDeploymentOrchestrator:
    def __init__(self):
        self.k8s = KubernetesClient()
        self.metrics = MetricsCollector()
        self.governance = GovernanceValidator()
    
    async def deploy_agent(
        self,
        agent_config: AgentConfig,
        deployment_config: DeploymentConfig
    ) -> DeploymentResult:
        """ปรับใช้ Agent ด้วยการตรวจสอบการกำกับดูแล"""
        
        # การตรวจสอบการกำกับดูลก่อนการปรับใช้
        governance_result = await self.governance.validate_deployment(
            agent_config
        )
        
        if not governance_result.approved:
            return DeploymentResult(
                success=False,
                reason=governance_result.reason,
                blocked_policies=governance_result.violated_policies
            )
        
        # ดำเนินการ Blue-Green Deployment
        if deployment_config.strategy == "blue_green":
            return await self._blue_green_deploy(agent_config, deployment_config)
        
        elif deployment_config.strategy == "canary":
            return await self._canary_deploy(agent_config, deployment_config)
        
        else:
            return await self._standard_deploy(agent_config, deployment_config)
    
    async def _blue_green_deploy(
        self,
        agent_config: AgentConfig,
        config: DeploymentConfig
    ) -> DeploymentResult:
        """ดำเนินการ Blue-Green Deployment"""
        
        # ปรับใช้เวอร์ชัน Green
        await self.k8s.deploy(
            name=f"{agent_config.name}-green",
            config=agent_config,
            replicas=config.green.replicas
        )
        
        # รัน Smoke Tests
        smoke_result = await self._run_smoke_tests(
            f"{agent_config.name}-green"
        )
        
        if not smoke_result.success:
            await self.k8s.delete(f"{agent_config.name}-green")
            return DeploymentResult(
                success=False,
                reason=f"Smoke tests ล้มเหลว: {smoke_result.errors}"
            )
        
        # เปลี่ยน Traffic อย่างค่อยเป็นค่อยไป
        for step in config.promotion.canary_steps:
            await self._shift_traffic(agent_config.name, step.traffic)
            
            # ตรวจสอบระหว่างขั้นตอน
            await asyncio.sleep(step.duration * 60)
            
            health = await self._check_health(agent_config.name)
            if not health.healthy:
                await self._rollback(agent_config.name)
                return DeploymentResult(
                    success=False,
                    reason=f"Health check ล้มเหลวที่ {step.traffic}% traffic"
                )
        
        # Promote Green เป็น Blue
        await self._promote_green_to_blue(agent_config.name)
        
        return DeploymentResult(
            success=True,
            version_deployed=agent_config.version
        )

# การกำหนดค่า Disaster Recovery ของ Agent
disaster_recovery:
  backup:
    frequency: hourly
    retention: 30d
    destinations:
      - s3://tropical-media-agent-backups/primary
      - s3://tropical-media-agent-backups-dr/secondary
    
    contents:
      - agent_configurations
      - workflow_definitions
      - execution_history
      - audit_logs
      - memory_snapshots
  
  rto: 15m  # เป้าหมายเวลากู้คืน
  rpo: 5m   # เป้าหมายจุดกู้คืน
  
  failover:
    regions:
      primary: us-east-1
      secondary: us-west-2
      tertiary: eu-west-1
    
    trigger_conditions:
      - primary_region_unavailable
      - error_rate > 0.5
      - latency_p99 > 5000ms
  
  testing:
    frequency: monthly
    scope: full_failover
    validation:
      - workflow_execution
      - data_integrity
      - performance_benchmark