"คุณเป็นตัวแทนฝ่ายสนับสนุนลูกค้าที่เป็นประโยชน์สำหรับ Acme Corp 
ตอบคำถามของลูกค้าอย่างสุภาพ เป็นมืออาชีพ และถูกต้อง 
ใช้ฐานความรู้ที่ให้มาเพื่อตอบคำถาม หากคุณไม่รู้บางอย่าง 
โอนสายไปยัง agent มนุษย์"

┌─────────────────────────────────────────────────────────────────┐
│                    วัฏจักร Feedback Loop                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│    ┌──────────────┐      ┌──────────────┐      ┌──────────────┐ │
│    │   EXECUTE    │─────▶│   OBSERVE    │─────▶│   EVALUATE   │ │
│    │              │      │              │      │              │ │
│    │ ทำงาน       │      │ บันทึกข้อมูล │      │ ประเมิน      │ │
│    │ สร้าง       │      │ บันทึกผลลัพธ์│      │ ประสิทธิภาพ  │ │
│    │ output      │      │ บันทึกบริบท  │      │ เทียบกับเป้า │ │
│    └──────────────┘      └──────────────┘      └──────┬───────┘ │
│           ▲                                          │          │
│           │                                          ▼          │
│           │                                   ┌──────────────┐ │
│           └───────────────────────────────────│    ADAPT     │ │
│                                               │              │ │
│                                               │ ปรับ         │ │
│                                               │ พารามิเตอร์  │ │
│                                               │ อัปเดตกฎ     │ │
│                                               └──────────────┘ │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    Loop Engineering Stack                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                   ชั้น ORCHESTRATION                     │  │
│  │              (n8n, OpenClaw, LangChain)                  │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────┼───────────────────────────────┐  │
│  │                           ▼                               │  │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐   │  │
│  │  │   AGENT     │  │    AGENT    │  │     AGENT       │   │  │
│  │  │  EXECUTION  │  │ OBSERVATION │  │   EVALUATION    │   │  │
│  │  └─────────────┘  └─────────────┘  └─────────────────┘   │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │                   การจัดการสถานะ                         │  │
│  │     (Redis, PostgreSQL, Vector Store, n8n Memory)      │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │                   FEEDBACK PIPELINE                      │  │
│  │    (Webhooks, Message Queues, Event Streams, APIs)        │  │
│  └──────────────────────────────────────────────────────────┘  │
│                              │                                   │
│  ┌───────────────────────────▼───────────────────────────────┐  │
│  │              เครื่องยนต์ ADAPTATION & LEARNING             │  │
│  │  (Prompt versioning, Parameter tuning, Model selection)   │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Execution → แยกเป็น Variant A หรือ B → เปรียบเทียบผลลัพธ์ 
→ ยอมรับ Variant ที่ประสิทธิภาพดีกว่า → ทำซ้ำด้วย Variations ใหม่

Execute → Error Detected → Analyze Error Type → 
Apply Recovery Strategy → Retry with Adjustments → 
Success/Failure → Update Error Handling Rules

Execute → Measure Performance (latency, cost, accuracy) → 
Identify Bottlenecks → Optimize → Validate Improvement → 
Deploy → Continue Monitoring

Execute → Detect Knowledge Gap → Retrieve Updated Information → 
Validate Against Sources → Update Knowledge Base → 
Re-execute with New Knowledge

┌─────────────────────────────────────────────────────────────────┐
│          สถาปัตยกรรม Self-Improving Support Agent              │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Webhook (ข้อความขาเข้า)                                         │
│       │                                                          │
│       ▼                                                          │
│  ดึง Session Memory (PostgreSQL)                                 │
│       │                                                          │
│       ▼                                                          │
│  AI Agent Node (GPT-4o พร้อม dynamic system prompt)             │
│       │                                                          │
│       ▼                                                          │
│  ส่งการตอบสนอง + เก็บ Implicit Feedback (เวลาตอบสนอง)           │
│       │                                                          │
│       ▼                                                          │
│  รอ Explicit Feedback (Webhook thumbs up/down)                │
│       │                                                          │
│       ▼                                                          │
│  ประเมิน: คำนวณคะแนนความพึงพอใจ                                 │
│       │                                                          │
│       ├── พอใจ (>80%) ──▶ จัดเก็บใน Success Patterns         │
│       │                                                          │
│       └── ไม่พอใจ (<80%) ──▶ Trigger Adaptation Loop             │
│                                     │                            │
│                                     ▼                            │
│                              วิเคราะห์ความล้มเหลว               │
│                                     │                            │
│                                     ▼                            │
│                              อัปเดต Prompt Rules                │
│                                     │                            │
│                                     ▼                            │
│                              บันทึกการปรับปรุงสำหรับ Session ถัดไป│
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// ใน AI Agent Node System Prompt
{{$json.currentPrompt}}

// currentPrompt ถูกดึงจาก PostgreSQL และอัปเดตโดย adaptation loop

// ตรรกะ Adaptation Workflow
// 1. ดึง 50 อินสแตนซ์ feedback ลบล่าสุด
// 2. จัดกลุ่มตามประเภทข้อผิดพลาด (tone, accuracy, completeness, etc.)
// 3. สร้างการปรับ prompt โดยใช้ LLM
// 4. ตรวจสอบการปรับกับ success patterns
// 5. อัปเดตตารางการกำหนดค่า
// 6. บันทึกการเปลี่ยนแปลงด้วยความสามารถในการ rollback

// Error Recovery Sub-Workflow

// Input: รายละเอียดข้อผิดพลาดจากการดำเนินการที่ล้มเหลว
const errorType = categorizeError($json.error);

const recoveryStrategies = {
  "RATE_LIMIT": {
    action: "retry",
    delay: "exponential_backoff",
    params: { baseDelay: 1000, maxRetries: 5 }
  },
  "TIMEOUT": {
    action: "retry",
    delay: "fixed",
    params: { delay: 5000, maxRetries: 3 }
  },
  "AUTHENTICATION": {
    action: "refresh_token",
    then: "retry"
  },
  "VALIDATION": {
    action: "modify_payload",
    strategy: "llm_fix",
    then: "retry"
  },
  "UNKNOWN": {
    action: "escalate",
    notify: ["admin", "error_log"]
  }
};

const strategy = recoveryStrategies[errorType] || recoveryStrategies["UNKNOWN"];

// อัปเดตสถิติข้อผิดพลาด
await updateErrorStats(errorType, $json.workflowId);

// หากอัตราข้อผิดพลาดเกินเกณฑ์ ให้ trigger adaptation
const errorRate = await getErrorRate($json.workflowId, "1h");
if (errorRate > 0.05) {
  await triggerAdaptation($json.workflowId, errorType);
}

return { strategy, shouldRetry: strategy.action !== "escalate" };

// Performance Monitor Workflow (ทำงานทุกชั่วโมง)

const metrics = await collectMetrics({
  timeRange: "1h",
  metrics: ["execution_time", "api_calls", "token_usage", "success_rate"]
});

// ระบุ workflows ที่มีประสิทธิภาพต่ำ
const underperforming = metrics.filter(m => 
  m.avgExecutionTime > threshold.executionTime ||
  m.successRate < threshold.successRate ||
  m.costPerExecution > threshold.cost
);

for (const workflow of underperforming) {
  // วิเคราะห์ข้อติดขัด
  const bottlenecks = await analyzeBottlenecks(workflow.id);
  
  // สร้างคำแนะนำการปรับปรุง
  const suggestions = await generateOptimizations(bottlenecks);
  
  // ทดสอบการปรับปรุงในโหมด shadow
  await deployShadowTest(workflow.id, suggestions);
  
  // หาก shadow test แสดงการปรับปรุง ให้ deploy ไปยัง production
  if (await validateShadowTest(workflow.id)) {
    await deployOptimization(workflow.id, suggestions);
    await notify("Optimization deployed", { workflow: workflow.name, improvements: suggestions });
  }
}

// SKILL.md สำหรับ skill ที่ปรับปรุงตัวเองได้

# Name: ผู้ช่วยสนับสนุนลูกค้า
# Version: 1.2.3

## การกำหนดค่า Loop

feedback_collection:
  channels: ["discord", "slack"]
  methods: ["reaction", "reply", "correction"]
  
evaluation:
  criteria:
    - accuracy: { weight: 0.4, min: 0.85 }
    - helpfulness: { weight: 0.3, min: 0.80 }
    - tone: { weight: 0.2, min: 0.75 }
    - efficiency: { weight: 0.1, max_tokens: 500 }
  
adaptation:
  trigger: "evaluation.score < 0.80"
  strategy: "prompt_refinement"
  max_iterations: 5
  rollback_on_failure: true

## ตรรกะการดำเนินการ

async function execute(message, context) {
  // โหลด prompt version ปัจจุบัน
  const promptVersion = context.state.promptVersion || "1.0";
  const prompt = await loadPrompt("customer-support", promptVersion);
  
  // สร้างการตอบสนอง
  const response = await llm.generate({
    prompt: prompt.template,
    context: message,
    history: context.memory.last(5)
  });
  
  // บันทึกการดำเนินการสำหรับ feedback
  await logExecution({
    executionId: generateId(),
    promptVersion,
    input: message,
    output: response,
    timestamp: Date.now()
  });
  
  return response;
}

## Feedback Handler

async function handleFeedback(executionId, feedback) {
  // ดึงบริบทการดำเนินการ
  const execution = await getExecution(executionId);
  
  // คำนวณคะแนนการประเมิน
  const score = calculateScore(feedback, execution);
  
  // จัดเก็บ feedback
  await storeFeedback({ executionId, feedback, score });
  
  // ตรวจสอบว่าต้องการ adaptation หรือไม่
  if (score < CONFIG.adaptation.threshold) {
    await triggerAdaptation(execution);
  }
  
  // อัปเดตสถิติ skill
  await updateStats({ score, execution });
}

## ตรรกะ Adaptation

async function adapt() {
  // รวบรวม instances ที่มีประสิทธิภาพต่ำล่าสุด
  const poorPerformers = await getExecutions({
    score: { $lt: CONFIG.adaptation.threshold },
    timeRange: "24h",
    limit: 50
  });
  
  // วิเคราะห์รูปแบบ
  const patterns = await analyzePatterns(poorPerformers);
  
  // สร้าง prompt ที่ปรับปรุงแล้ว
  const newPrompt = await generateImprovedPrompt({
    current: await loadPrompt("customer-support"),
    failures: patterns,
    successes: await getSuccessPatterns()
  });
  
  // ตรวจสอบการปรับปรุง
  const validation = await validatePrompt(newPrompt);
  
  if (validation.score > CONFIG.adaptation.improvementThreshold) {
    // Deploy version ใหม่
    await deployPrompt("customer-support", newPrompt);
    await notify(`Prompt updated to version ${newPrompt.version}`);
  }
}

┌─────────────────────────────────────────────────────────────────┐
│              การรวม OpenClaw + n8n Loop                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   OpenClaw Agent                     n8n Workflow             │
│   ──────────────                     ─────────────             │
│                                                                  │
│   การโต้ตอบของผู้ใช้ ──Webhook──▶ Workflow Trigger              │
│         │                                                        │
│         │                            ┌──────────────────┐       │
│         │                            │ ประมวลผลคำขอ   │       │
│         │                            │ - ดึงข้อมูล     │       │
│         │                            │ - ดำเนินการตรรกะ│       │
│         │                            └────────┬─────────┘       │
│         │                                     │                  │
│         │                            ┌────────▼─────────┐       │
│         │                            │ AI Agent Node    │       │
│         │                            │ สร้างการตอบสนอง │       │
│         │                            └────────┬─────────┘       │
│         │                                     │                  │
│         │                            ┌────────▼─────────┐       │
│         └──────────Webhook───────────│ ส่งคืนการตอบสนอง│       │
│                                      └──────────────────┘       │
│                                                   │              │
│                                      ┌────────────▼─────────┐   │
│                                      │ การเก็บรวบรวม Feedback│   │
│                                      │ - จัดเก็บ execution   │   │
│                                      │ - รอ feedback ของ    │   │
│                                      │   ผู้ใช้             │   │
│                                      └────────────┬─────────┘   │
│                                                   │              │
│                                      ┌────────────▼─────────┐   │
│                                      │ Adaptation Loop      │   │
│                                      │ - ประเมินผลลัพธ์     │   │
│                                      │ - อัปเดตการกำหนดค่า   │   │
│                                      │   OpenClaw           │   │
│                                      └──────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

ผู้ใช้: "ฉันจะรีเซ็ตรหัสผ่านได้อย่างไร?"

AI: "คุณสามารถรีเซ็ตรหัสผ่านได้โดยคลิก 'ลืมรหัสผ่าน' 
     บนหน้าเข้าสู่ระบบ อีเมลพร้อมคำแนะนำในการรีเซ็ต 
     จะถูกส่งไปยังที่อยู่ที่ลงทะเบียนไว้
     
     มีประโยชน์หรือไม่? [👍 ใช่] [👎 ไม่] [💬 ถามต่อ]"
     
ผู้ใช้คลิก 👍

ระบบ: บันทึก feedback ในเชิงบวก จับคู่กับการตอบสนอง

// การสร้างการตอบสนองพร้อม inline feedback
const response = await generateResponse(userMessage);

const responseWithFeedback = {
  text: response.text,
  buttons: [
    { label: "👍 ใช่", value: "feedback:positive", style: "primary" },
    { label: "👎 ไม่", value: "feedback:negative", style: "danger" },
    { label: "💬 ถามต่อ", value: "feedback:followup", style: "secondary" }
  ]
};

// ส่งการตอบสนอง
await sendMessage(userId, responseWithFeedback);

// ตั้งค่า webhook เพื่อจับการคลิกปุ่ม
// Webhook handler ดึง executionId จากค่าปุ่ม
// และกำหนดเส้นทางไปยัง feedback processing workflow

วันที่ 0: AI คัดกรอง lead, จัดตาราง demo
วันที่ 1: Lead เข้าร่วม demo
วันที่ 7: Lead แปลงเป็นผู้ซื้อ (หรือไม่)
วันที่ 7: ระบบประเมินประสิทธิภาพของการสนทนา
        ตามผลการแปลงจริง

// หลังการโต้ตอบเริ่มต้น
await scheduleDelayedFeedback({
  executionId: currentExecution.id,
  delay: "7d",
  evaluationCriteria: "conversion_outcome",
  dataSource: "crm"
});

// Delayed feedback workflow (ถูกกระตุ้นโดย cron)
const pendingFeedback = await getPendingFeedback();

for (const item of pendingFeedback) {
  const outcome = await checkOutcome(item.executionId);
  const feedback = convertOutcomeToFeedback(outcome);
  await processFeedback(item.executionId, feedback);
}

// สัญญาณ feedback โดยอ้อม

const signals = {
  // สัญญาณการมีส่วนร่วม
  "การตอบสนองรวดเร็ว": { weight: 0.3, sentiment: "positive" },
  "คำถามติดตามผล": { weight: 0.4, sentiment: "positive" },
  "การสนทนาดำเนินต่อ": { weight: 0.2, sentiment: "positive" },
  
  // สัญญาณการขาดการมีส่วนร่วม  
  "ไม่มีการตอบสนอง 24h": { weight: 0.5, sentiment: "negative" },
  "การสนทนาสิ้นสุดกะทันหัน": { weight: 0.4, sentiment: "negative" },
  "ถูกยกระดับไปยังมนุษย์": { weight: 0.6, sentiment: "negative" },
  
  // สัญญาณความสำเร็จ
  "งานเสร็จสมบูรณ์": { weight: 0.8, sentiment: "positive" },
  "คำแนะนำถูกยอมรับ": { weight: 0.7, sentiment: "positive" },
  "ตรวจพบความรู้สึกเชิงบวก": { weight: 0.5, sentiment: "positive" }
};

// คำนวณคะแนนโดยอ้อม
function calculateImplicitScore(execution, events) {
  let score = 0.5; // ฐาน neutral
  
  for (const event of events) {
    const signal = signals[event.type];
    if (signal) {
      score += signal.weight * (signal.sentiment === "positive" ? 1 : -1);
    }
  }
  
  return Math.max(0, Math.min(1, score)); // จำกัดไว้ที่ [0, 1]
}

// คิวการตรวจสอบของผู้เชี่ยวชาญ

const reviewQueue = await getExecutionsRequiringReview({
  criteria: [
    "confidence_score < 0.8",
    "user_expressed_dissatisfaction",
    "escalated_to_human"
  ],
  limit: 10
});

// อินเทอร์เฟซการตรวจสอบของผู้เชี่ยวชาญแสดง:
// - บริบทการสนทนาเต็มรูปแบบ
// - การตอบสนอง AI พร้อมจุด feedback เฉพาะ
// - การเปรียบเทียบกับการตอบสนองที่ดีที่สุด
// - แบบฟอร์มการประเมินที่มีโครงสร้าง

const expertFeedback = {
  executionId: execution.id,
  reviewer: expert.id,
  ratings: {
    accuracy: 4,      // สเกล 1-5
    helpfulness: 3,
    tone: 5,
    efficiency: 4
  },
  corrections: {
    improvedResponse: "การใช้คำที่ดีกว่าคือ...",
    reasoning: "คำอธิบายทางเทคนิคซับซ้อนเกินไป..."
  },
  tags: ["technical_depth", "jargon"]
};

await storeExpertFeedback(expertFeedback);

// การกำหนดค่า: เก็บข้อความล่าสุด N ข้อความ
{
  "mode": "window",
  "windowSize": 10,
  "persistence": "redis"
}

// กรณีใช้งาน: Chatbot รักษาบริบทการสนทนา
// หน้าต่างเลื่อน เก็บบริบทล่าสุดไว้
// บริบทที่เก่ากว่าถูกสรุปหรือเก็บถาวร

// การกำหนดค่า: ประวัติไม่จำกัดพร้อม token limit
{
  "mode": "buffer",
  "maxTokens": 8000,
  "persistence": "postgresql"
}

// กรณีใช้งาน: Session การสนับสนุนลูกค้าที่
// การสนทนาเต็มรูปแบบมีความสำคัญต่อบริบท
// จัดการงบประมาณโทเค็นโดยอัตโนมัติ

// การกำหนดค่า: Cross-execution persistence
{
  "mode": "session",
  "sessionKey": "user_{{$json.userId}}",
  "persistence": "postgresql",
  "ttl": "30d"
}

// กรณีใช้งาน: การเรียนรู้ความชอบของผู้ใช้ข้าม
// หลายการสนทนาในระยะเวลาหลายสัปดาห์

// ตัวอย่าง: สถานะ loop การสนับสนุนลูกค้า

const stateSchema = {
  // การระบุ session
  sessionId: "string",
  userId: "string",
  startedAt: "timestamp",
  
  // บริบทการสนทนา
  messages: [{
    role: "enum:user|assistant|system",
    content: "string",
    timestamp: "timestamp",
    feedback: "object|null"
  }],
  
  // การติดตามประสิทธิภาพ
  metrics: {
    responseCount: "number",
    avgResponseTime: "number",
    satisfactionScore: "number",
    escalationCount: "number"
  },
  
  // สถานะการเรียนรู้
  userPreferences: {
    technicalLevel: "enum:beginner|intermediate|expert",
    preferredTone: "enum:formal|casual",
    commonIssues: ["string"]
  },
  
  // snapshot การกำหนดค่า
  activeConfig: {
    promptVersion: "string",
    model: "string",
    parameters: "object"
  }
};

// เมื่อสถานะเปลี่ยนแปลง เผยแพร่ event
await publishEvent("state:updated", {
  sessionId,
  changes,
  timestamp
});

// ผู้สมัครรับอัปเดตสำเนาสถานะของพวกเขา

// Cron job ทำงานทุกนาที
const dirtySessions = await getDirtySessions();
for (const session of dirtySessions) {
  await syncToSecondaryStorage(session);
  await markClean(session.id);
}

// เมื่อการอัปเดตที่เกิดขึ้นพร้อมกัน
function resolveConflict(local, remote, strategy = "timestamp") {
  switch(strategy) {
    case "timestamp":
      return local.updatedAt > remote.updatedAt ? local : remote;
    case "merge":
      return deepMerge(local, remote);
    case "manual":
      queueForManualResolution(local, remote);
      return local;
  }
}

ทำงาน → สร้าง Output เริ่มต้น → สะท้อนคุณภาพ → 
ระบุปัญหา → แก้ไข Output → ส่งมอบขั้นสุดท้าย → บันทึก Reflection

// Reflection sub-workflow

async function reflectOnOutput({ task, initialOutput, criteria }) {
  const reflectionPrompt = `
    คุณกำลังประเมินงานของตนเอง ตรวจสอบงานและ output ด้านล่าง
    จากนั้นระบุปัญหาหรือพื้นที่ที่ต้องการการปรับปรุงใดๆ
    
    งาน: ${task}
    Output ของคุณ: ${initialOutput}
    
    เกณฑ์การประเมิน:
    ${criteria.map(c => `- ${c.name}: ${c.description}`).join('\n')}
    
    ให้ข้อมูล:
    1. คะแนนสำหรับแต่ละเกณฑ์ (1-5)
    2. ปัญหาเฉพาะที่ระบุ
    3. การปรับปรุงที่แนะนำ
    4. การประเมินโดยรวม: PASS หรือ REVISE
    
    จัดรูปแบบการตอบสนองของคุณเป็น JSON
  `;
  
  const reflection = await llm.generate({
    prompt: reflectionPrompt,
    temperature: 0.3,
    responseFormat: { type: "json_object" }
  });
  
  return JSON.parse(reflection);
}

// Main workflow
const initialOutput = await generateResponse(input);
const reflection = await reflectOnOutput({
  task: input.task,
  initialOutput,
  criteria: qualityCriteria
});

let finalOutput = initialOutput;
if (reflection.overallAssessment === "REVISE") {
  finalOutput = await reviseOutput(initialOutput, reflection.suggestedImprovements);
}

// บันทึก reflection เพื่อการเรียนรู้
await logReflection({
  executionId,
  reflection,
  initialOutput,
  finalOutput,
  revisionCount: reflection.overallAssessment === "REVISE" ? 1 : 0
});

const reflectionCriteria = {
  accuracy: {
    description: "ความถูกต้องตามข้อเท็จจริงและการสอดคล้องกับข้อมูล source",
    questions: [
      "ข้อเท็จจริงทั้งหมดได้รับการสนับสนุนจากบริบทที่ให้มาหรือไม่?",
      "มีการอ้างอิงที่ไม่มีการสนับสนุนหรือไม่?",
      "ข้อมูลเป็นปัจจุบันหรือไม่?"
    ]
  },
  completeness: {
    description: "การครอบคลุมทุกแง่มุมที่เกี่ยวข้องของงาน",
    questions: [
      "ฉันได้ตอบสนองทุกส่วนของคำขอของผู้ใช้หรือไม่?",
      "มีบริบทสำคัญที่ฉันพลาดไปหรือไม่?",
      "ข้อมูลเพิ่มเติมจะมีประโยชน์หรือไม่?"
    ]
  },
  clarity: {
    description: "ความง่ายในการเข้าใจและโทนที่เหมาะสม",
    questions: [
      "ภาษาชัดเจนและไม่คลุมเครือหรือไม่?",
      "โทนเหมาะสมกับผู้ชมหรือไม่?",
      "ผู้ไม่มีความเชี่ยวชาญจะเข้าใจสิ่งนี้หรือไม่?"
    ]
  },
  conciseness: {
    description: "ประสิทธิภาพของการสื่อสาร",
    questions: [
      "มีการซ้ำซ้อนที่ไม่จำเป็นหรือไม่?",
      "สิ่งนี้สามารถกล่าวสั้นกว่านี้ได้หรือไม่?",
      "รายละเอียดทั้งหมดที่รวมไว้มีความเกี่ยวข้องหรือไม่?"
    ]
  },
  actionability: {
    description: "ประโยชน์สำหรับขั้นตอนต่อไปของผู้ใช้",
    questions: [
      "สิ่งนี้ช่วยให้ผู้ใช้ดำเนินการได้หรือไม่?",
      "ขั้นตอนต่อไปชัดเจนหรือไม่?",
      "มีความคลุมเครือเกี่ยวกับสิ่งที่ต้องทำหรือไม่?"
    ]
  }
};

async function multiPassReflection(content, maxPasses = 3) {
  let current = content;
  let pass = 0;
  let shouldContinue = true;
  
  while (shouldContinue && pass < maxPasses) {
    const reflection = await reflectOnOutput(current);
    
    if (reflection.overallAssessment === "PASS" || 
        reflection.avgScore >= 4.5) {
      shouldContinue = false;
    } else {
      current = await reviseOutput(current, reflection.suggestedImprovements);
      pass++;
    }
    
    // หยุดหากการปรับปรุงระหว่าง pass น้อย
    if (pass > 0 && reflection.scoreDelta < 0.1) {
      shouldContinue = false;
    }
  }
  
  return {
    output: current,
    passes: pass + 1,
    finalReflection: reflection
  };
}

// รวม reflection ข้อมูล
const reflectionPatterns = await aggregateReflections({
  timeRange: "7d",
  groupBy: ["criteria", "issueType"]
});

// ระบุ failure modes ทั่วไป
const commonIssues = reflectionPatterns
  .filter(r => r.frequency > threshold)
  .sort((a, b) => b.frequency - a.frequency);

// สร้างการปรับปรุงที่กำหนดเป้าหมาย
for (const issue of commonIssues) {
  const improvement = await generateImprovement({
    issue: issue.description,
    examples: issue.examples,
    currentPrompt: await getCurrentPrompt()
  });
  
  await deployImprovement(improvement);
}

const errorTaxonomy = {
  TRANSIENT: {
    description: "ปัญหาชั่วคราวที่อาจแก้ไขได้เมื่อ retry",
    examples: ["หมดเวลาเครือข่าย", "จำกัดอัตรา", "บริการไม่พร้อมใช้งานชั่วคราว"],
    strategy: "RETRY_WITH_BACKOFF",
    maxRetries: 5
  },
  
  AUTHENTICATION: {
    description: "ปัญหาข้อมูลรับรองหรือสิทธิ์",
    examples: ["API key ไม่ถูกต้อง", "Token หมดอายุ", "สิทธิ์ไม่เพียงพอ"],
    strategy: "REFRESH_AND_RETRY",
    maxRetries: 2
  },
  
  VALIDATION: {
    description: "ปัญหารูปแบบ input หรือ output",
    examples: ["Schema mismatch", "ขาดฟิลด์ที่จำเป็น", "รูปแบบไม่ถูกต้อง"],
    strategy: "REPAIR_AND_RETRY",
    maxRetries: 3
  },
  
  DEPENDENCY: {
    description: "บริการหรือข้อมูลที่จำเป็นไม่พร้อมใช้งาน",
    examples: ["การเชื่อมต่อฐานข้อมูลล้มเหลว", "External API ล่ม", "ไม่พบไฟล์"],
    strategy: "ESCALATE_OR_DEFER",
    maxRetries: 1
  },
  
  LOGIC: {
    description: "ข้อผิดพลาดตรรกะ workflow",
    examples: ["เงื่อนไขที่ไม่คาดคิด", "ตรวจพบ infinite loop", "ความไม่สอดคล้องของสถานะ"],
    strategy: "ESCALATE_TO_HUMAN",
    maxRetries: 0
  },
  
  RESOURCE: {
    description: "การใช้ทรัพยากรหมด",
    examples: ["หน่วยความจำไม่เพียงพอ", "ดิสก์เต็ม", "เกินขีดจำกัดอัตรา"],
    strategy: "SCALE_OR_DEFER",
    maxRetries: 3
  }
};

async function adaptiveRetry(operation, context) {
  const errorHistory = await getErrorHistory(context.operationId);
  const baseConfig = await getRetryConfig(context.operationType);
  
  // ปรับกลยุทธ์ตามรูปแบบประวัติ
  const adjustedConfig = adjustStrategy(baseConfig, errorHistory);
  
  let attempt = 0;
  let lastError = null;
  
  while (attempt < adjustedConfig.maxRetries) {
    try {
      const result = await operation();
      
      // บันทึกความสำเร็จหลังจากความล้มเหลวก่อนหน้า
      if (attempt > 0) {
        await logRecovery({ context, attempts: attempt, strategy: adjustedConfig });
      }
      
      return { success: true, result, attempts: attempt + 1 };
      
    } catch (error) {
      lastError = error;
      const errorType = classifyError(error);
      
      // ตรวจสอบว่าสามารถ retry ได้หรือไม่
      if (!isRetryable(errorType)) {
        break;
      }
      
      // คำนวณ delay ด้วย exponential backoff และ jitter
      const delay = calculateDelay(attempt, adjustedConfig, errorType);
      
      // อัปเดตกลยุทธ์สำหรับความพยายามถัดไป
      adjustedConfig = await updateStrategy(adjustedConfig, error, attempt);
      
      attempt++;
      await sleep(delay);
    }
  }
  
  // Retries ทั้งหมดหมดแล้ว
  await logPermanentFailure({ context, error: lastError, attempts });
  return { success: false, error: lastError, attempts };
}

function calculateDelay(attempt, config, errorType) {
  const baseDelay = config.baseDelays[errorType] || config.baseDelay;
  const exponential = Math.pow(2, attempt);
  const jitter = Math.random() * config.jitterFactor * baseDelay;
  
  return Math.min(
    baseDelay * exponential + jitter,
    config.maxDelay
  );
}

class CircuitBreaker {
  constructor(options = {}) {
    this.failureThreshold = options.failureThreshold || 5;
    this.recoveryTimeout = options.recoveryTimeout || 60000;
    this.halfOpenMaxCalls = options.halfOpenMaxCalls || 3;
    
    this.state = "CLOSED"; // CLOSED, OPEN, HALF_OPEN
    this.failures = 0;
    this.nextAttempt = Date.now();
    this.halfOpenCalls = 0;
  }
  
  async execute(operation) {
    if (this.state === "OPEN") {
      if (Date.now() < this.nextAttempt) {
        throw new CircuitOpenError("บริการไม่พร้อมใช้งานชั่วคราว");
      }
      this.state = "HALF_OPEN";
      this.halfOpenCalls = 0;
    }
    
    if (this.state === "HALF_OPEN" && this.halfOpenCalls >= this.halfOpenMaxCalls) {
      throw new CircuitOpenError("Circuit breaker ถึงขีดจำกัด half-open");
    }
    
    if (this.state === "HALF_OPEN") {
      this.halfOpenCalls++;
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  
  onSuccess() {
    this.failures = 0;
    this.state = "CLOSED";
  }
  
  onFailure() {
    this.failures++;
    if (this.failures >= this.failureThreshold) {
      this.state = "OPEN";
      this.nextAttempt = Date.now() + this.recoveryTimeout;
    }
  }
}

// การใช้งานใน n8n Function node
const breaker = new CircuitBreaker({
  failureThreshold: 5,
  recoveryTimeout: 60000
});

const result = await breaker.execute(() => 
  callExternalAPI(input)
);

// ขั้นตอนการวิเคราะห์ข้อผิดพลาด
async function analyzeErrors(timeRange = "24h") {
  const errors = await getErrors({
    timeRange,
    resolved: true
  });
  
  // จัดกลุ่มตามประเภทและรูปแบบข้อผิดพลาด
  const patterns = groupByPattern(errors);
  
  for (const pattern of patterns) {
    // ระบุ root causes
    const rootCause = await identifyRootCause(pattern);
    
    // สร้างมาตรการป้องกัน
    const prevention = await generatePrevention(rootCause);
    
    // อัปเดต workflows หากความเชื่อมั่นสูง
    if (prevention.confidence > 0.8) {
      await deployPrevention(prevention);
    }
    
    // บันทึกสำหรับการตรวจสอบด้วยตนเองหากความเชื่อมั่นปานกลาง
    if (prevention.confidence > 0.5) {
      await queueForReview({ pattern, rootCause, prevention });
    }
  }
}

function optimizeContext(history, currentTask) {
  // การให้คะแนนความเกี่ยวข้อง
  const scored = history.map(msg => ({
    ...msg,
    relevance: calculateRelevance(msg, currentTask)
  }));
  
  // เก็บข้อความที่เกี่ยวข้องมากที่สุดภายในงบประมาณโทเค็น
  const sorted = scored.sort((a, b) => b.relevance - a.relevance);
  const budget = getTokenBudget();
  
  let currentTokens = 0;
  const included = [];
  
  for (const msg of sorted) {
    const msgTokens = estimateTokens(msg.content);
    if (currentTokens + msgTokens < budget) {
      included.push(msg);
      currentTokens += msgTokens;
    }
  }
  
  // กลับไปเรียงลำดับตามเวลา
  return included.sort((a, b) => a.timestamp - b.timestamp);
}

async function summarizeConversation(messages) {
  // สำหรับการสนทนาที่ยาว สร้างการแสดงผลที่กระชับ
  if (messages.length > 20) {
    const summary = await llm.generate({
      prompt: `สรุปประเด็นสำคัญจากการสนทนานี้ใน 3-5 ข้อ:
               ${formatMessages(messages.slice(0, -5))}`,
      maxTokens: 200
    });
    
    return [
      { role: "system", content: `สรุปการสนทนา: ${summary}` },
      ...messages.slice(-5) // เก็บข้อความล่าสุดเต็มรูปแบบ
    ];
  }
  
  return messages;
}

async function selectModel(task, context) {
  const complexity = await assessComplexity(task, context);
  
  const tiers = {
    SIMPLE: { model: "gpt-4o-mini", cost: 0.15 },
    STANDARD: { model: "gpt-4o", cost: 2.50 },
    COMPLEX: { model: "gpt-4-turbo", cost: 10.00 },
    REASONING: { model: "o1-preview", cost: 15.00 }
  };
  
  const selection = tiers[complexity] || tiers.STANDARD;
  
  // ตรวจสอบว่าสามารถ downgraded ตามประวัติหรือไม่
  const similarTasks = await getSimilarTaskPerformance(task);
  if (similarTasks.simpleModelSuccessRate > 0.95) {
    return tiers.SIMPLE;
  }
  
  return selection;
}

function shouldRunFullLoop(execution, config) {
  // ข้ามสำหรับงานที่ไม่สำคัญ
  if (execution.complexity === "LOW") {
    return false;
  }
  
  // ข้ามหากเพิ่งประเมินไป
  const lastEvaluation = execution.lastEvaluation;
  if (lastEvaluation && Date.now() - lastEvaluation < config.minLoopInterval) {
    return false;
  }
  
  // ข้ามหากความเชื่อมั่นสูง
  if (execution.confidenceScore > config.confidenceThreshold) {
    return false;
  }
  
  // ดำเนินการเสมอหากตรวจพบข้อผิดพลาด
  if (execution.errorCount > 0) {
    return true;
  }
  
  // สุ่มตัวอย่างตามอัตราที่กำหนดค่า
  return Math.random() < config.samplingRate;
}

// ตัวกลางการติดตามต้นทุน
async function trackExecutionCost(execution) {
  const costs = {
    llmCalls: execution.llmCalls * avgCostPerCall(execution.model),
    storage: execution.storageUsed * storageRate,
    compute: execution.duration * computeRate,
    bandwidth: execution.dataTransferred * bandwidthRate
  };
  
  const total = Object.values(costs).reduce((a, b) => a + b, 0);
  
  await logCost({
    executionId: execution.id,
    workflowId: execution.workflowId,
    costs,
    total,
    timestamp: Date.now()
  });
  
  // Alert เมื่อต้นทุนผิดปกติ
  const avgCost = await getAverageCost(execution.workflowId, "7d");
  if (total > avgCost * 3) {
    await sendAlert({
      type: "COST_ANOMALY",
      execution: execution.id,
      cost: total,
      average: avgCost
    });
  }
  
  // Circuit breaker สำหรับต้นทุนที่มากเกินไป
  const dailyCost = await getDailyCost(execution.workflowId);
  const budget = await getBudget(execution.workflowId);
  if (dailyCost > budget * 0.8) {
    await activateCostLimiter(execution.workflowId);
  }
}

Agent A ───┐
           ├──▶ การประเมินร่วม ▶── การปรับตัวที่ประสานงาน
Agent B ───┘            ▲                    │
                        └────────────────────┘

// ผู้ประสานงานกลางจัดการ loops ของ agents ทั้งหมด
class LoopCoordinator {
  constructor() {
    this.agents = new Map();
    this.sharedState = new Map();
  }
  
  registerAgent(agentId, config) {
    this.agents.set(agentId, {
      config,
      lastEvaluation: null,
      performance: []
    });
  }
  
  async coordinate(feedback) {
    // รวม feedback ข้าม agents
    const aggregate = await this.aggregateFeedback(feedback);
    
    // ระบุรูปแบบระดับระบบ
    const patterns = await this.identifyPatterns(aggregate);
    
    // กำหนดการปรับตัวที่ประสานงาน
    const adaptations = await this.planAdaptations(patterns);
    
    // แจกจ่ายการปรับตัวไปยัง agents
    for (const [agentId, adaptation] of adaptations) {
      await this.sendAdaptation(agentId, adaptation);
    }
    
    // บันทึกการตัดสินใจในการประสานงาน
    await this.logCoordination({ aggregate, patterns, adaptations });
  }
  
  async identifyPatterns(aggregate) {
    // ตรวจจับเมื่อ agents หลายตัวดิ้นรนกับงานที่คล้ายกัน
    const commonIssues = aggregate.filter(a => 
      a.frequency > 1 && a.affectedAgents.length > 1
    );
    
    // ระบุความขัดแย้งด้านทรัพยากร
    const conflicts = detectConflicts(aggregate);
    
    // หาโอกาสในการปรับปรุง
    const optimizations = findOptimizations(aggregate);
    
    return { commonIssues, conflicts, optimizations };
  }
}

// Agents ต่อรองการปรับตัว peer-to-peer
async function negotiateAdaptation(agentId, proposedChange) {
  // สอบถาม agents อื่นเพื่อประเมินผลกระทบ
  const impacts = await Promise.all(
    peerAgents.map(peer => 
      assessImpact(peer, proposedChange)
    )
  );
  
  // หากตรวจพบความขัดแย้ง ให้ต่อรองประนีประนอม
  const conflicts = impacts.filter(i => i.conflict);
  if (conflicts.length > 0) {
    const compromise = await generateCompromise(proposedChange, conflicts);
    return { approved: true, adjustment: compromise };
  }
  
  // ไม่มีความขัดแย้ง ดำเนินการต้นฉบับ
  return { approved: true, adjustment: proposedChange };
}

// การประสานงานหลายระดับ
const coordinationHierarchy = {
  level1: {
    agents: ["support-agent", "sales-agent"],
    scope: "customer-facing",
    coordinator: "customer-coordinator"
  },
  level2: {
    agents: ["customer-coordinator", "operations-agent"],
    scope: "business-operations",
    coordinator: "operations-coordinator"
  },
  level3: {
    agents: ["operations-coordinator", "strategy-agent"],
    scope: "strategic",
    coordinator: "executive-coordinator"
  }
};

// Feedback ฟองขึ้น, การปรับตัวลดลง
async function hierarchicalCoordination(feedback, level) {
  const config = coordinationHierarchy[level];
  
  // ประมวลผลที่ระดับปัจจุบัน
  const adaptations = await processAtLevel(feedback, config);
  
  // ฟองขึ้นหากสำคัญ
  if (adaptations.significance > threshold && level < maxLevel) {
    await hierarchicalCoordination(adaptations, level + 1);
  }
  
  // ลดลงสำหรับการปรับตัวที่ได้รับการอนุมัติ
  for (const agent of config.agents) {
    await applyAdaptation(agent, adaptations);
  }
}

const conflictResolutionStrategies = {
  PRIORITY: (conflicts) => {
    // Agent ที่มี priority สูงกว่าชนะ
    return conflicts.sort((a, b) => b.priority - a.priority)[0];
  },
  
  MERGE: (conflicts) => {
    // พยายามรวมการปรับตัว
    return attemptMerge(conflicts);
  },
  
  COMPROMISE: (conflicts) => {
    // หาจุดกลาง
    return findCompromise(conflicts);
  },
  
  EXPERIMENT: (conflicts) => {
    // ทำ A/B test
    return scheduleExperiment(conflicts);
  },
  
  ESCALATE: (conflicts) => {
    // ต้องการการตัดสินใจของมนุษย์
    return escalateToHuman(conflicts);
  }
};

ได้รับ ticket → AI สร้างการตอบสนอง → ส่งไปยังลูกค้า → 
รวบรวมความพึงพอใจ → หากต่ำ ให้วิเคราะห์ → อัปเดตกลยุทธ์การตอบสนอง → 
นำไปใช้กับ tickets ในอนาคต

const supportLoop = {
  triggers: ["new_ticket", "satisfaction_survey"],
  
  evaluate: async (ticket) => {
    const metrics = {
      resolvedFirstTime: ticket.resolvedWithoutFollowUp,
      csat: ticket.satisfactionRating,
      escalated: ticket.wasEscalated,
      responseTime: ticket.firstResponseTime
    };
    
    const score = weightedAverage(metrics, weights);
    return { score, metrics };
  },
  
  adapt: async (lowPerformanceInstances) => {
    // ระบุรูปแบบความล้มเหลวที่พบบ่อย
    const patterns = analyzePatterns(lowPerformanceInstances);
    
    // อัปเดตช่องโหว่ในฐานความรู้
    if (patterns.knowledgeGaps) {
      await queueKnowledgeUpdates(patterns.knowledgeGaps);
    }
    
    // ปรับแต่งโทนหากมีการร้องเรียนเกี่ยวกับการสื่อสาร
    if (patterns.toneIssues) {
      await updateToneGuidelines(patterns.toneIssues);
    }
    
    // ปรับ thresholds การยกระดับ
    if (patterns.underEscalation) {
      await lowerEscalationThreshold();
    }
  }
};

Lead เข้าสู่ pipeline → AI คัดกรอง → การติดต่อที่เป็นเอกลักษณ์ → 
ติดตาม engagement → วัด conversion → ปรับปรุงเกณฑ์การคัดกรอง

const salesLoop = {
  // Feedback loop ที่ล่าช้า
  evaluationDelay: "30d",
  
  evaluate: async (lead) => {
    const outcome = await checkOutcome(lead.id);
    return {
      converted: outcome.isCustomer,
      revenue: outcome.lifetimeValue,
      cycleDays: outcome.daysToClose,
      qualifiedCorrectly: outcome.wasQualified === outcome.shouldHaveBeenQualified
    };
  },
  
  adapt: async (results) => {
    // อัปเดต qualification model
    const newCriteria = await retrainQualificationModel(results);
    await deployQualificationModel(newCriteria);
    
    // ปรับปรุง outreach sequences
    const sequences = await optimizeSequences(results);
    await updateOutreachTemplates(sequences);
    
    // ปรับ lead scoring
    await updateLeadScoringWeights(results);
  }
};

สร้าง draft content → Human/editor review → เผยแพร่ → 
ติดตาม engagement → วิเคราะห์ประสิทธิภาพ → ปรับปรุงกลยุทธ์การสร้าง

const contentLoop = {
  // Human-in-the-loop สำหรับคุณภาพ
  humanReview: true,
  
  evaluate: async (content) => {
    const performance = await getContentMetrics(content.id);
    return {
      engagement: performance.avgTimeOnPage,
      reach: performance.uniqueVisitors,
      viral: performance.shares,
      conversion: performance.conversionRate,
      seo: performance.searchRanking
    };
  },
  
  adapt: async (performanceData) => {
    // ระบุรูปแบบ content ที่มีประสิทธิภาพสูง
    const winners = performanceData.filter(p => p.conversion > threshold);
    const patterns = extractPatterns(winners);
    
    // อัปเดตแนวทางการสร้าง content
    await updateContentGuidelines(patterns);
    
    // ปรับการเลือกหัวข้อ
    await updateTopicModel(patterns.topics);
    
    // ปรับโทนและสไตล์
    await updateStyleGuide(patterns.style);
  }
};

นักพัฒนาขอโค้ด → AI สร้าง → นักพัฒนาใช้ → 
ติดตามการยอมรับ/การปฏิเสธ → วัดคุณภาพโค้ด → อัปเดตรูปแบบการสร้าง

const codingLoop = {
  // Feedback หลายระดับ
  feedbackLevels: ["immediate", "code_review", "production"],
  
  evaluate: async (codeBlock) => {
    const immediate = await getImmediateFeedback(codeBlock.id);
    const review = await getReviewFeedback(codeBlock.id);
    const production = await getProductionMetrics(codeBlock.id);
    
    return {
      accepted: immediate.accepted,
      modified: immediate.modificationRate,
      reviewComments: review.commentCount,
      bugsFound: production.bugCount,
      performance: production.performanceScore
    };
  },
  
  adapt: async (evaluations) => {
    // อัปเดต coding patterns
    const patterns = await analyzeCodePatterns(evaluations);
    await updateCodingGuidelines(patterns);
    
    // เรียนรู้ conventions เฉพาะโปรเจกต์
    const conventions = await extractConventions(evaluations);
    await updateProjectProfile(conventions);
    
    // ปรับสำหรับประเภทงานที่แตกต่างกัน
    await updateTaskTypeStrategies(evaluations);
  }
};

const governanceFramework = {
  // Workflows การอนุมัติสำหรับการปรับตัว
  approval: {
    automatic: {
      criteria: [
        "confidence > 0.95",
        "tested_in_staging",
        "no_security_implications",
        "rollout_percentage <= 10"
      ]
    },
    manual: {
      criteria: [
        "confidence < 0.95",
        "affects_core_functionality",
        "has_security_implications",
        "rollout_percentage > 10"
      ]
    }
  },
  
  // Audit logging
  audit: {
    logAll: true,
    retention: "7y",
    include: [
      "original_state",
      "proposed_change",
      "evaluation_data",
      "approval_chain",
      "deployment_timestamp",
      "outcome_metrics"
    ]
  },
  
  // ความสามารถในการ rollback
  rollback: {
    automaticTriggers: [
      "error_rate_increase > 50%",
      "satisfaction_decrease > 20%",
      "security_alert"
    ],
    maxRollbackTime: "24h",
    preserveState: true
  }
};

async function proposeAdaptation(proposal) {
  // สแกนความปลอดภัย
  const securityScan = await scanForSecurityIssues(proposal);
  if (securityScan.issues.length > 0) {
    return { approved: false, reason: "security_concerns" };
  }
  
  // ตรวจสอบการปฏิบัติตามนโยบาย
  const compliance = await checkPolicyCompliance(proposal);
  if (!compliance.compliant) {
    return { approved: false, reason: "policy_violation", details: compliance.violations };
  }
  
  // กำหนดเส้นทางการอนุมัติ
  const path = determineApprovalPath(proposal);
  
  if (path === "automatic") {
    // Deploy ไปยัง canary
    await deployCanary(proposal);
    await scheduleEvaluation(proposal.id, "1h");
    return { approved: true, deployment: "canary" };
  }
  
  // เข้าคิวสำหรับการตรวจสอบด้วยตนเอง
  await queueForReview(proposal);
  return { approved: false, status: "pending_review" };
}

async function checkForBias(feedbackData) {
  // ตรวจสอบความแตกต่างทางประชากร
  const demographics = await analyzeByDemographics(feedbackData);
  
  const disparities = [];
  for (const demo of demographics) {
    const performanceGap = calculateGap(demo, overallAverage);
    if (performanceGap > threshold) {
      disparities.push({
        demographic: demo.name,
        gap: performanceGap,
        affectedMetric: demo.metric
      });
    }
  }
  
  if (disparities.length > 0) {
    await alertBias(disparities);
    
    // ใช้การแก้ไข
    await applyBiasCorrection(disparities);
    
    // ต้องการการตรวจสอบด้วยตนเองก่อนการปรับตัวเพิ่มเติม
    await pauseAutomaticAdaptations();
  }
}

// การบันทึก audit ที่ครอบคลุม
async function logAdaptationEvent(event) {
  const auditRecord = {
    timestamp: Date.now(),
    eventId: generateId(),
    eventType: event.type,
    
    // รายละเอียดการเปลี่ยนแปลง
    change: {
      before: event.previousState,
      after: event.newState,
      diff: calculateDiff(event.previousState, event.newState)
    },
    
    // เหตุผลในการตัดสินใจ
    rationale: {
      trigger: event.trigger,
      evaluationData: event.evaluation,
      confidence: event.confidence,
      alternativesConsidered: event.alternatives
    },
    
    // Governance
    governance: {
      approvedBy: event.approver,
      approvalChain: event.approvals,
      securityScan: event.securityResult,
      complianceCheck: event.complianceResult
    },
    
    // ผลกระทบ
    impact: {
      rolloutPercentage: event.rollout,
      affectedUsers: event.userCount,
      expectedOutcome: event.expectedResult
    }
  };
  
  await storeAuditRecord(auditRecord);
  await indexForCompliance(auditRecord);
}

// รัน adaptations ใหม่ควบคู่ไปกับของเก่า
async function shadowTest(adaptation) {
  // ประมวลผล input เดียวกันทั้งเก่าและใหม่
  const oldResult = await executeWithConfig(currentConfig, input);
  const newResult = await executeWithConfig(adaptation, input);
  
  // เปรียบเทียบผลลัพธ์
  const comparison = await compareResults(oldResult, newResult);
  
  // บันทึกสำหรับการวิเคราะห์
  await logShadowTest({
    adaptation: adaptation.id,
    input: input.id,
    oldResult,
    newResult,
    comparison
  });
  
  // แสดงความแตกต่างที่สำคัญเท่านั้น
  if (comparison.significantDifference) {
    await flagForReview({ adaptation, input, comparison });
  }
}

async function abTestAdaptation(adaptation) {
  // แยก traffic
  const assignment = Math.random() < 0.5 ? "control" : "treatment";
  
  if (assignment === "treatment") {
    await applyAdaptation(adaptation);
  }
  
  // ติดตามประสิทธิภาพสำหรับทั้งสองกลุ่ม
  const performance = await trackPerformance({
    adaptation: adaptation.id,
    assignment,
    duration: "7d"
  });
  
  // ทดสอบความสำคัญทางสถิติ
  const significance = await calculateSignificance(performance);
  
  if (significance.pValue < 0.05 && performance.treatment > performance.control) {
    await fullDeployment(adaptation);
  } else {
    await rollback(adaptation);
  }
}