┌─────────────────────────────────────────────────────────────────────────────────┐
│              The AI Autonomy Spectrum: From Full Human to Full Agent            │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  HUMAN-DRIVEN                              FULLY AUTONOMOUS                     │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐            │
│  │                 │    │                 │    │                 │            │
│  │   AI as Tool    │───▶│  Human-in-Loop  │───▶│ AI as Agent     │            │
│  │                 │    │                 │    │                 │            │
│  └─────────────────┘    └─────────────────┘    └─────────────────┘            │
│         2020-2023            2024-2026+           2027+ (Selective)             │
│                                                                                 │
│  • Human initiates      • AI proposes,        • AI executes                    │
│  • AI assists           • Human approves        • Human monitors                 │
│  • Human decides        • Collaborative         • Exception handling           │
│                                                                                 │
│  Current State:         Emerging Pattern:       Target State:                    │
│  ChatGPT, Copilot       n8n + AI + HITL         Supervised autonomy            │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    Human Involvement Patterns Comparison                         │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   HOOTL              HOTL                    HITL                               │
│   (No Human)         (Supervisory)           (Collaborative)                    │
│                                                                                 │
│   ┌─────────┐        ┌─────────┐             ┌─────────┐                     │
│   │   AI    │        │   AI    │             │   AI    │                     │
│   │  Agent  │        │  Agent  │             │  Agent  │                     │
│   └────┬────┘        └────┬────┘             └────┬────┘                     │
│        │                  │                        │                           │
│        │                  │    ┌─────────┐         │    ┌─────────┐            │
│        │                  ├───▶│ Human   │         ├───▶│ Human   │            │
│        │                  │    │ Monitor │◄────────│    │ Review  │            │
│        │                  │    └─────────┘         │    └────┬────┘            │
│        │                  │         │              │       │                  │
│        ▼                  ▼         ▼              ▼       ▼                  │
│   ┌─────────┐        ┌─────────┐             ┌─────────┐                     │
│   │ Execute │        │ Execute │             │ Execute │                     │
│   │ (Auto)  │        │ (Auto)  │             │ (After  │                     │
│   └─────────┘        └─────────┘             │Approval)│                     │
│                                                └─────────┘                     │
│                                                                                 │
│   Risk: HIGH         Risk: MEDIUM            Risk: LOW                         │
│   Speed: MAX         Speed: HIGH             Speed: MODERATE                    │
│   Trust: LOW         Trust: MEDIUM          Trust: HIGH                      │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

// Workflow: AI Content Approval Pipeline
// Nodes: Webhook → AI Agent → Approval Request → Condition → Execute/Publish

// Node 1: Webhook Trigger (receives content request)
{
  "name": "Content Request",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "https://your-n8n.com/webhook/content-approval",
  "responseMode": "responseNode"
}

// Node 2: AI Content Generation (OpenAI/Claude)
{
  "name": "Generate Content",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "options": {
    "options": {
      "systemMessage": "You are a professional content writer...",
      "temperature": 0.7
    }
  },
  "prompt": "={{ $json.query }}"
}

// Node 3: Store Pending Approval (Database)
{
  "name": "Create Approval Record",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "content_approvals",
  "columns": {
    "content_id": "={{ $json.id }}",
    "content": "={{ $json.generated_content }}",
    "status": "pending",
    "requested_by": "={{ $json.user }}",
    "created_at": "={{ $now }}"
  }
}

// Node 4: Send Approval Request (Slack/Email)
{
  "name": "Request Approval",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "content-approvers",
  "text": "📝 New content requires approval",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Content Ready for Review*\n{{ $json.content_preview }}"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✅ Approve" },
          "action_id": "approve_content",
          "value": "{{ $json.content_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "❌ Reject" },
          "action_id": "reject_content",
          "value": "{{ $json.content_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✏️ Edit" },
          "action_id": "edit_content",
          "url": "https://cms.example.com/edit/{{ $json.content_id }}"
        }
      ]
    }
  ]
}

// Node 5: Wait for Approval Response
{
  "name": "Wait for Approval",
  "type": "n8n-nodes-base.wait",
  "waitType": "webhook",
  "webhookSuffix": "approval-response",
  "continue": "receiveWebhook"
}

// Node 6: Process Approval Decision
{
  "name": "Approval Decision",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "string": [
      { "value1": "={{ $json.action }}", "value2": "approved" }
    ]
  }
}

// Branch: Approved → Publish
{
  "name": "Publish Content",
  "type": "n8n-nodes-base.httpRequest",
  "method": "POST",
  "url": "https://cms.example.com/api/publish",
  "body": {
    "content_id": "={{ $json.content_id }}",
    "approved_by": "={{ $json.approver }}",
    "approved_at": "={{ $now }}"
  }
}

// Branch: Rejected → Notify & Log
{
  "name": "Rejection Handler",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "content-requests",
  "text": "❌ Content rejected by {{ $json.approver }}: {{ $json.rejection_reason }}"
}

// Workflow: Intelligent Exception Routing

// Node 1: Receive Input (from AI system or external source)
{
  "name": "Input Processing",
  "type": "n8n-nodes-base.webhook"
}

// Node 2: Confidence Scoring and Risk Assessment
{
  "name": "Calculate Confidence",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    // Calculate composite confidence score
    const aiConfidence = $json.ai_confidence || 0;
    const patternMatch = $json.similarity_score || 0;
    const historicalAccuracy = $json.model_accuracy || 0.85;
    
    // Weighted confidence calculation
    const confidenceScore = (
      aiConfidence * 0.5 +
      patternMatch * 0.3 +
      historicalAccuracy * 0.2
    );
    
    // Risk assessment
    const riskFactors = [];
    if ($json.amount > 10000) riskFactors.push('high_value');
    if ($json.customer_tier === 'enterprise') riskFactors.push('vip_customer');
    if ($json.is_novel_situation) riskFactors.push('novel_case');
    
    return [{
      json: {
        ...$json,
        confidence_score: confidenceScore,
        risk_factors: riskFactors,
        risk_level: riskFactors.length > 1 ? 'high' : riskFactors.length > 0 ? 'medium' : 'low',
        requires_human_review: confidenceScore < 0.8 || riskFactors.length > 0
      }
    }];
  `
}

// Node 3: Routing Decision
{
  "name": "Route Decision",
  "type": "n8n-nodes-base.switch",
  "rules": {
    "rules": [
      {
        "value": "={{ $json.requires_human_review }}",
        "output": 0  // Route to human
      },
      {
        "value": "={{ true }}",
        "output": 1  // Auto-process
      }
    ]
  }
}

// Route 0: Human Review Queue
{
  "name": "Create Ticket",
  "type": "n8n-nodes-base.jira",
  "operation": "create",
  "project": "AIEX",
  "issueType": "Exception",
  "summary": "AI Exception: {{ $json.case_type }} - Confidence {{ $json.confidence_score }}",
  "description": `
    *AI Processing Results:*
    - Confidence Score: {{ $json.confidence_score }}
    - Risk Factors: {{ $json.risk_factors.join(', ') }}
    - AI Recommendation: {{ $json.ai_recommendation }}
    
    *Context:*
    {{ JSON.stringify($json.context, null, 2) }}
    
    [View in AI Dashboard](https://ai.example.com/cases/{{ $json.case_id }})
  `,
  "priority": "={{ $json.risk_level === 'high' ? 'High' : 'Medium' }}"
}

// Route 1: Auto-Process
{
  "name": "Auto-Execute",
  "type": "n8n-nodes-base.httpRequest",
  "url": "https://api.example.com/execute",
  "method": "POST",
  "body": "={{ $json }}"
}

// Node 4: Queue Management and Load Balancing
{
  "name": "Assign to Specialist",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH available_experts AS (
      SELECT expert_id, current_load, specialization
      FROM expert_queue
      WHERE status = 'available'
      AND specialization && $1
      ORDER BY current_load ASC
      LIMIT 1
    )
    UPDATE expert_queue
    SET current_load = current_load + 1,
        assigned_case = $2
    WHERE expert_id = (SELECT expert_id FROM available_experts)
    RETURNING expert_id
  `,
  "parameters": [
    "={{ $json.risk_factors }}",
    "={{ $json.case_id }}"
  ]
}

// Node 5: Real-time Notification
{
  "name": "Notify Expert",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "@{{ $json.expert_id }}",
  "text": "🔔 Exception case assigned",
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "⚠️ Exception Case Requires Attention" }
    },
    {
      "type": "section",
      "fields": [
        { "type": "mrkdwn", "text": "*Case ID:*\n{{ $json.case_id }}" },
        { "type": "mrkdwn", "text": "*Risk Level:*\n{{ $json.risk_level }}" },
        { "type": "mrkdwn", "text": "*Confidence:*\n{{ $json.confidence_score }}" },
        { "type": "mrkdwn", "text": "*Wait Time:*\n{{ $json.queue_time }}" }
      ]
    }
  ]
}

// Workflow: Interactive AI Refinement with Real-time Collaboration

// Node 1: WebSocket Connection for Real-time Communication
{
  "name": "WebSocket Handler",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "/ws/interactive-ai",
  "responseMode": "responseNode"
}

// Node 2: Session Management
{
  "name": "Initialize Session",
  "type": "n8n-nodes-base.redis",
  "operation": "set",
  "key": "session:{{ $json.session_id }}",
  "value": {
    "status": "active",
    "iteration": 0,
    "context": [],
    "created_at": "{{ $now }}"
  },
  "expire": 3600  // 1 hour TTL
}

// Node 3: AI Generation with Context
{
  "name": "Generate with Context",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "prompt": `
    Previous iterations: {{ $json.history }}
    Current feedback: {{ $json.feedback }}
    Task: {{ $json.task }}
    
    Generate an improved version incorporating the feedback.
  `,
  "options": {
    "systemMessage": "You are an AI assistant that learns from feedback..."
  }
}

// Node 4: Store Iteration
{
  "name": "Save Iteration",
  "type": "n8n-nodes-base.redis",
  "operation": "set",
  "key": "session:{{ $json.session_id }}:iteration:{{ $json.iteration }}",
  "value": {
    "output": "{{ $json.ai_output }}",
    "feedback": "{{ $json.feedback }}",
    "timestamp": "{{ $now }}"
  }
}

// Node 5: Send to User Interface
{
  "name": "Push to UI",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "/ui/update",
  "body": {
    "session_id": "{{ $json.session_id }}",
    "iteration": "{{ $json.iteration }}",
    "content": "{{ $json.ai_output }}",
    "suggestions": "{{ $json.alternatives }}",
    "changes_summary": "{{ $json.diff_from_previous }}"
  }
}

// Node 6: Wait for User Feedback
{
  "name": "Collect Feedback",
  "type": "n8n-nodes-base.wait",
  "waitType": "webhook",
  "webhookSuffix": "user-feedback",
  "continue": "receiveWebhook"
}

// Node 7: Check for Completion
{
  "name": "Completion Check",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "string": [
      { "value1": "={{ $json.action }}", "value2": "approve" }
    ]
  }
}

// Approved Branch: Finalize
{
  "name": "Finalize Output",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    // Compile all iterations into final document
    const iterations = $json.history;
    const finalVersion = $json.current_version;
    
    return [{
      json: {
        final_output: finalVersion,
        revision_history: iterations,
        total_iterations: iterations.length,
        time_to_complete: Date.now() - new Date($json.session_created).getTime(),
        approved_by: $json.user_id,
        approved_at: new Date().toISOString()
      }
    }];
  `
}

// Feedback Branch: Continue Loop
{
  "name": "Increment Iteration",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    return [{
      json: {
        ...$json,
        iteration: ($json.iteration || 0) + 1,
        feedback: $json.user_feedback
      }
    }];
  `
}
// Loop back to Node 3 (Generate with Context)

<template>
  <div class="interactive-ai-session">
    <!-- Current AI Output -->
    <div class="ai-output" v-if="currentOutput">
      <div class="content" v-html="renderedContent"></div>
      
      <!-- Inline Commenting -->
      <CommentSystem 
        :content="currentOutput"
        @comment="addInlineFeedback"
      />
    </div>
    
    <!-- Feedback Controls -->
    <div class="feedback-controls">
      <button @click="provideFeedback('continue')">
        👍 Looks good, continue
      </button>
      <button @click="provideFeedback('revise')">
        🔄 Revise with changes
      </button>
      <button @click="provideFeedback('approve')">
        ✅ Approve final version
      </button>
      
      <!-- Detailed Feedback Input -->
      <textarea 
        v-model="detailedFeedback"
        placeholder="What would you like to change?"
      />
      
      <!-- Suggested Changes -->
      <SuggestedEdits
        :suggestions="aiSuggestions"
        @apply="applySuggestion"
      />
    </div>
    
    <!-- Iteration History -->
    <div class="iteration-history">
      <div 
        v-for="(iter, idx) in history" 
        :key="idx"
        class="iteration"
      >
        <span>Version {{ idx + 1 }}</span>
        <span>{{ iter.timestamp }}</span>
        <button @click="restoreVersion(iter)">Restore</button>
      </div>
    </div>
  </div>
</template>

<script setup>
import { ref, onMounted } from 'vue'
import { useWebSocket } from '@vueuse/core'

const sessionId = ref(generateSessionId())
const currentOutput = ref('')
const history = ref([])
const detailedFeedback = ref('')

const { send, status } = useWebSocket(
  `wss://your-n8n.com/ws/interactive-ai?session=${sessionId.value}`,
  {
    onMessage: (msg) => {
      const data = JSON.parse(msg.data)
      currentOutput.value = data.content
      history.value.push(data)
    }
  }
)

const provideFeedback = (action) => {
  send(JSON.stringify({
    session_id: sessionId.value,
    action,
    feedback: detailedFeedback.value,
    timestamp: new Date().toISOString()
  }))
}
</script>

// Workflow: Feedback Capture and Model Improvement Pipeline

// Node 1: Capture Correction
{
  "name": "Correction Event",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "/feedback/correction"
}

// Node 2: Store in Feedback Database
{
  "name": "Log Correction",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "ai_feedback",
  "columns": {
    "original_prediction": "={{ $json.ai_output }}",
    "human_correction": "={{ $json.corrected_output }}",
    "correction_type": "={{ $json.correction_category }}",
    "model_version": "={{ $json.model_version }}",
    "confidence_at_prediction": "={{ $json.confidence }}",
    "context": "={{ JSON.stringify($json.context) }}",
    "created_at": "={{ $now }}"
  }
}

// Node 3: Calculate Model Drift
{
  "name": "Analyze Error Patterns",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH recent_errors AS (
      SELECT correction_type, COUNT(*) as count
      FROM ai_feedback
      WHERE created_at > NOW() - INTERVAL '7 days'
      GROUP BY correction_type
    ),
    baseline AS (
      SELECT correction_type, COUNT(*) as count
      FROM ai_feedback
      WHERE created_at > NOW() - INTERVAL '30 days'
        AND created_at <= NOW() - INTERVAL '7 days'
      GROUP BY correction_type
    )
    SELECT 
      r.correction_type,
      r.count as recent_count,
      b.count as baseline_count,
      ((r.count - b.count)::float / NULLIF(b.count, 0)) as drift_percentage
    FROM recent_errors r
    LEFT JOIN baseline b ON r.correction_type = b.correction_type
    WHERE ((r.count - b.count)::float / NULLIF(b.count, 0)) > 0.2
  `
}

// Node 4: Trigger Retraining if Needed
{
  "name": "Check Retraining Threshold",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "number": [
      { "value1": "={{ $json.length }}", "operation": "gt", "value2": 5 }
    ]
  }
}

// Retraining Branch
{
  "name": "Trigger Model Retraining",
  "type": "n8n-nodes-base.httpRequest",
  "method": "POST",
  "url": "https://ml-ops.example.com/retrain",
  "body": {
    "model_id": "{{ $json.model_id }}",
    "new_training_data_query": "SELECT * FROM ai_feedback WHERE created_at > NOW() - INTERVAL '30 days'",
    "priority": "high"
  }
}

// Node 5: Update Training Dataset
{
  "name": "Export to Training Pipeline",
  "type": "n8n-nodes-base.s3",
  "operation": "upload",
  "bucket": "ai-training-data",
  "key": "corrections/{{ $now.format('YYYY/MM/DD') }}/{{ $json.id }}.json",
  "data": "={{ JSON.stringify($json) }}"
}

// Node 6: Notify ML Team
{
  "name": "Alert on Drift",
  "type": "n8n-nodes-base.slack",
  "condition": "={{ $json.drift_percentage > 0.3 }}",
  "operation": "post",
  "channel": "#ml-alerts",
  "text": "⚠️ Model drift detected: {{ $json.correction_type }} errors up {{ $json.drift_percentage }}%"
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│                         HITL Architecture Layers                                │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                         Presentation Layer                               │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │   │
│  │  │   Slack     │  │   Email     │  │  Web Portal │  │   Mobile    │     │   │
│  │  │  Interface  │  │  Interface  │  │             │  │     App     │     │   │
│  │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘     │   │
│  └─────────┼────────────────┼────────────────┼────────────────┼────────────┘   │
│            │                │                │                │                  │
│            └────────────────┴────────────────┴────────────────┘                  │
│                                     │                                           │
│                                     ▼                                           │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                        Orchestration Layer (n8n)                         │   │
│  │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐           │   │
│  │  │  Webhook        │  │  Wait Nodes     │  │  State Machine  │           │   │
│  │  │  Handlers       │  │  & Timeouts     │  │  Management     │           │   │
│  │  └─────────────────┘  └─────────────────┘  └─────────────────┘           │   │
│  │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐           │   │
│  │  │  Conditional    │  │  Error          │  │  Retry          │           │   │
│  │  │  Logic          │  │  Handling       │  │  Logic          │           │   │
│  │  └─────────────────┘  └─────────────────┘  └─────────────────┘           │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                     │                                           │
│           ┌─────────────────────────┼─────────────────────────┐                  │
│           │                         │                         │                  │
│           ▼                         ▼                         ▼                  │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐            │
│  │   AI Services   │    │  Human Systems  │    │ Business Systems│            │
│  │  ┌───────────┐  │    │  ┌───────────┐  │    │  ┌───────────┐  │            │
│  │  │ OpenAI    │  │    │  │   Jira    │  │    │  │   CRM     │  │            │
│  │  │ Claude    │  │    │  │ ServiceNow│  │    │  │   ERP     │  │            │
│  │  │ Llama     │  │    │  │ Zendesk   │  │    │  │ Database  │  │            │
│  │  │ Custom    │  │    │  │ Slack     │  │    │  │ APIs      │  │            │
│  │  └───────────┘  │    │  └───────────┘  │    │  └───────────┘  │            │
│  └─────────────────┘    └─────────────────┘    └─────────────────┘            │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

// Node: Idempotency Check
{
  "name": "Check for Duplicate",
  "type": "n8n-nodes-base.redis",
  "operation": "get",
  "key": "idempotency:{{ $json.request_id }}"
}

// Node: Conditional Execution
{
  "name": "Skip if Already Processed",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "string": [
      { "value1": "={{ $json.exists }}", "value2": "true" }
    ]
  }
}

// If not exists, mark as processing and continue
{
  "name": "Mark Processing",
  "type": "n8n-nodes-base.redis",
  "operation": "set",
  "key": "idempotency:{{ $json.request_id }}",
  "value": "processing",
  "expire": 3600
}

// State Machine Implementation
const states = {
  INIT: 'initialized',
  AI_PROCESSING: 'ai_processing',
  WAITING_APPROVAL: 'waiting_approval',
  APPROVED: 'approved',
  REJECTED: 'rejected',
  EXECUTING: 'executing',
  COMPLETED: 'completed',
  FAILED: 'failed',
  TIMEOUT: 'timeout'
};

const transitions = {
  [states.INIT]: [states.AI_PROCESSING],
  [states.AI_PROCESSING]: [states.WAITING_APPROVAL, states.FAILED],
  [states.WAITING_APPROVAL]: [states.APPROVED, states.REJECTED, states.TIMEOUT],
  [states.APPROVED]: [states.EXECUTING],
  [states.EXECUTING]: [states.COMPLETED, states.FAILED]
};

// Validate transitions
function canTransition(from, to) {
  return transitions[from]?.includes(to);
}

// Node: Validate Approver Identity
{
  "name": "Verify Approver",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const approver = $json.approver_email;
    const requiredApprovalLevel = $json.approval_level;
    
    // Check against directory service
    const userProfile = await fetchUserFromDirectory(approver);
    
    // Validate approval authority
    if (!userProfile.approval_levels.includes(requiredApprovalLevel)) {
      throw new Error(
        \`User \${approver} is not authorized for \${requiredApprovalLevel} approvals\`
      );
    }
    
    // Check for delegation
    if (userProfile.is_delegated) {
      $json.actual_approver = userProfile.delegated_to;
      $json.delegation_chain = [approver, userProfile.delegated_to];
    }
    
    return [$json];
  `
}

// Node: Audit Logging
{
  "name": "Security Audit Log",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "security_audit",
  "columns": {
    "event_type": "approval_action",
    "actor": "={{ $json.approver_email }}",
    "action": "={{ $json.decision }}",
    "resource": "={{ $json.request_id }}",
    "ip_address": "={{ $json.client_ip }}",
    "user_agent": "={{ $json.user_agent }}",
    "timestamp": "={{ $now }}"
  }
}

// Node: PII Redaction Before Logging
{
  "name": "Sanitize for Logs",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const sensitiveFields = ['ssn', 'credit_card', 'password', 'dob'];
    const sanitized = { ...$json };
    
    sensitiveFields.forEach(field => {
      if (sanitized[field]) {
        sanitized[field] = '[REDACTED]';
      }
    });
    
    // Also check nested objects
    function redactNested(obj, fields) {
      for (const key in obj) {
        if (fields.includes(key.toLowerCase())) {
          obj[key] = '[REDACTED]';
        } else if (typeof obj[key] === 'object') {
          redactNested(obj[key], fields);
        }
      }
    }
    
    redactNested(sanitized, sensitiveFields);
    return [{ json: sanitized }];
  `
}

// Node: Cache AI Results for Similar Requests
{
  "name": "Check Cache",
  "type": "n8n-nodes-base.redis",
  "operation": "get",
  "key": "ai-cache:{{ $json.request_hash }}"
}

// Node: Cache Hit Response
{
  "name": "Return Cached",
  "type": "n8n-nodes-base.respondToWebhook",
  "respondWith": "json",
  "responseBody": {
    "result": "={{ $json.cached_result }}",
    "source": "cache",
    "cached_at": "={{ $json.cached_at }}"
  }
}

// Node: Cache Miss - Call AI and Store
{
  "name": "Cache Result",
  "type": "n8n-nodes-base.redis",
  "operation": "set",
  "key": "ai-cache:{{ $json.request_hash }}",
  "value": "={{ JSON.stringify($json.ai_result) }}",
  "expire": 86400  // 24 hours
}

// Node: Batch Similar Approvals
{
  "name": "Collect Batch",
  "type": "n8n-nodes-base.aggregate",
  "aggregate": "individualFields",
  "destinationFieldName": "batch",
  "fieldsToAggregate": {
    "include": ["request_id", "content", "approval_type"]
  },
  "options": {
    "batchSize": 10,
    "batchTimeout": 300  // seconds
  }
}

// Node: Present Batch for Bulk Approval
{
  "name": "Batch Approval UI",
  "type": "n8n-nodes-base.slack",
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "📦 Batch Approval Required" }
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "{{ $json.batch.length }} items pending approval"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✅ Approve All" },
          "action_id": "approve_batch"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "👀 Review Individually" },
          "url": "https://approvals.example.com/batch/{{ $json.batch_id }}"
        }
      ]
    }
  ]
}

// Workflow: Intelligent Loan Document Review

// Stage 1: Document Intake and Classification
{
  "name": "Document Ingestion",
  "type": "n8n-nodes-base.s3",
  "event": "s3:ObjectCreated:*",
  "bucket": "loan-documents"
}

// Stage 2: AI Document Analysis
{
  "name": "Extract Key Fields",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "prompt": `
    Analyze this loan application and extract:
    - Applicant income and employment
    - Requested loan amount and purpose
    - Debt-to-income ratio
    - Collateral details
    - Risk indicators
    
    Provide confidence scores for each extraction.
  `
}

// Stage 3: Risk Scoring and Routing
{
  "name": "Calculate Risk Score",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const factors = {
      income_verification: $json.income_confidence,
      employment_stability: $json.employment_confidence,
      credit_history: $json.credit_score,
      collateral_value: $json.collateral_confidence,
      purpose_clarity: $json.purpose_confidence
    };
    
    // Weighted risk calculation
    const weights = {
      income_verification: 0.25,
      employment_stability: 0.20,
      credit_history: 0.30,
      collateral_value: 0.15,
      purpose_clarity: 0.10
    };
    
    let riskScore = 0;
    let requiresReview = false;
    let reviewReasons = [];
    
    for (const [factor, confidence] of Object.entries(factors)) {
      riskScore += (1 - confidence) * weights[factor];
      if (confidence < 0.7) {
        requiresReview = true;
        reviewReasons.push(\`Low confidence in \${factor}: \${confidence}\`);
      }
    }
    
    // Auto-approve thresholds
    const autoApprove = (
      riskScore < 0.2 &&
      $json.loan_amount < 100000 &&
      $json.credit_score > 700
    );
    
    return [{
      json: {
        ...$json,
        risk_score: riskScore,
        requires_human_review: requiresReview || !autoApprove,
        auto_approve_eligible: autoApprove,
        review_reasons: reviewReasons,
        queue_priority: riskScore > 0.5 ? 'high' : 'normal'
      }
    }];
  `
}

// Stage 4: Intelligent Queue Assignment
{
  "name": "Route to Underwriter",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH available_underwriters AS (
      SELECT u.id, u.name, u.current_workload, u.specializations
      FROM underwriters u
      WHERE u.status = 'available'
      AND u.max_workload > u.current_workload
      AND ($1 && u.specializations OR array_length(u.specializations, 1) IS NULL)
      ORDER BY u.current_workload ASC, 
               CASE WHEN $2 > 0.5 THEN u.expertise_score ELSE 0 END DESC
      LIMIT 1
    )
    UPDATE underwriters
    SET current_workload = current_workload + 1,
        assigned_application = $3
    WHERE id = (SELECT id FROM available_underwriters)
    RETURNING id, name
  `,
  "parameters": [
    "={{ $json.specializations_needed }}",
    "={{ $json.risk_score }}",
    "={{ $json.application_id }}"
  ]
}

// Stage 5: Underwriter Interface
{
  "name": "Present Review Interface",
  "type": "n8n-nodes-base.webhook",
  "method": "POST",
  "url": "https://underwriter-portal.example.com/review",
  "body": {
    "application": {
      "id": "{{ $json.application_id }}",
      "ai_analysis": "{{ $json.ai_results }}",
      "extracted_documents": "{{ $json.documents }}",
      "risk_score": "{{ $json.risk_score }}",
      "confidence_breakdown": "{{ $json.confidence_scores }}"
    },
    "decision_options": [
      { "value": "approve", "label": "Approve as Recommended" },
      { "value": "approve_with_conditions", "label": "Approve with Conditions" },
      { "value": "reject", "label": "Reject" },
      { "value": "request_more_info", "label": "Request Additional Information" }
    ],
    "required_fields": ["decision", "justification"]
  }
}

// Stage 6: Decision Processing
{
  "name": "Process Underwriter Decision",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const decision = $json.underwriter_decision;
    
    // Compare AI vs Human decision for model improvement
    const aiDecision = $json.ai_recommendation;
    const agreement = aiDecision === decision.decision;
    
    // Update application status
    await updateApplicationStatus($json.application_id, {
      status: decision.decision,
      reviewed_by: decision.underwriter_id,
      reviewed_at: new Date(),
      ai_human_agreement: agreement
    });
    
    // Log for model training
    await logDecisionFeedback({
      application_id: $json.application_id,
      ai_prediction: aiDecision,
      human_decision: decision.decision,
      agreement,
      correction_category: agreement ? 'correct' : 'incorrect',
      context: $json
    });
    
    return [{ json: { ...$json, processed: true } }];
  `
}

// Workflow: Tiered Content Moderation

// Stage 1: Real-time Content Ingestion
{
  "name": "Content Stream",
  "type": "n8n-nodes-base.kafkaTrigger",
  "topic": "content-published",
  "groupId": "moderation-processor"
}

// Stage 2: Multi-model AI Analysis
{
  "name": "Parallel AI Analysis",
  "type": "n8n-nodes-base.parallel",
  "branches": [
    {
      "name": "Toxicity Detection",
      "type": "n8n-nodes-base.httpRequest",
      "url": "https://ai-moderation.example.com/toxicity",
      "method": "POST"
    },
    {
      "name": "Spam Detection",
      "type": "n8n-nodes-base.httpRequest",
      "url": "https://ai-moderation.example.com/spam",
      "method": "POST"
    },
    {
      "name": "Misinformation Check",
      "type": "n8n-nodes-base.httpRequest",
      "url": "https://ai-moderation.example.com/fact-check",
      "method": "POST"
    }
  ]
}

// Stage 3: Ensemble Decision
{
  "name": "Aggregate Scores",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const toxicity = $json[0].toxicity_score;
    const spam = $json[1].spam_probability;
    const misinfo = $json[2].misinformation_score;
    
    // Weighted ensemble
    const overallRisk = (
      toxicity * 0.5 +
      spam * 0.25 +
      misinfo * 0.25
    );
    
    // Decision categories
    let action, reason, priority;
    
    if (overallRisk > 0.9) {
      action = 'auto_remove';
      reason = 'High confidence violation';
      priority = 'critical';
    } else if (overallRisk > 0.7) {
      action = 'escalate_human';
      reason = 'Likely violation, needs review';
      priority = 'high';
    } else if (overallRisk > 0.4) {
      action = 'escalate_human';
      reason = 'Uncertain, safety review';
      priority = 'normal';
    } else {
      action = 'allow';
      reason = 'Low risk';
      priority = 'low';
    }
    
    return [{
      json: {
        content_id: $json.content_id,
        risk_scores: { toxicity, spam, misinfo },
        overall_risk: overallRisk,
        recommended_action: action,
        reason,
        priority,
        flagged_at: new Date().toISOString()
      }
    }];
  `
}

// Stage 4: Human Review Queue
{
  "name": "Create Review Task",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "string": [
      { "value1": "={{ $json.recommended_action }}", "value2": "escalate_human" }
    ]
  }
}

// Human Review Branch
{
  "name": "Moderator Assignment",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH qualified_mods AS (
      SELECT m.id, m.name, m.workload, m.specialization,
             m.accuracy_score, m.response_time_avg
      FROM moderators m
      WHERE m.status = 'online'
      AND m.current_workload < m.max_workload
      AND ($1 = ANY(m.specialization) OR $2 = 'normal')
      ORDER BY m.accuracy_score DESC, m.response_time_avg ASC
      LIMIT 1
    )
    UPDATE moderators
    SET current_workload = current_workload + 1,
        last_assigned = NOW()
    WHERE id = (SELECT id FROM qualified_mods)
    RETURNING id, name, specialization
  `,
  "parameters": [
    "={{ $json.violation_type }}",
    "={{ $json.priority }}"
  ]
}

// Stage 5: Real-time Moderator Interface
{
  "name": "Send to Moderator",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "@{{ $json.moderator_id }}",
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "🚨 Content Requires Review" }
    },
    {
      "type": "section",
      "fields": [
        { "type": "mrkdwn", "text": "*Risk Score:*\n{{ $json.overall_risk }}" },
        { "type": "mrkdwn", "text": "*Priority:*\n{{ $json.priority }}" },
        { "type": "mrkdwn", "text": "*Toxicity:*\n{{ $json.risk_scores.toxicity }}" },
        { "type": "mrkdwn", "text": "*Spam:*\n{{ $json.risk_scores.spam }}" }
      ]
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Content Preview:*\n>>>{{ $json.content_preview }}"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✅ Allow" },
          "style": "primary",
          "action_id": "allow_content",
          "value": "{{ $json.content_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "❌ Remove" },
          "style": "danger",
          "action_id": "remove_content",
          "value": "{{ $json.content_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "👁️ View Full" },
          "url": "https://mod.example.com/review/{{ $json.content_id }}"
        }
      ]
    },
    {
      "type": "context",
      "elements": [
        {
          "type": "mrkdwn",
          "text": "SLA: {{ $json.priority === 'high' ? '2 min' : '15 min' }}"
        }
      ]
    }
  ]
}

// Stage 6: SLA Monitoring
{
  "name": "SLA Alert",
  "type": "n8n-nodes-base.cron",
  "cronExpression": "*/2 * * * *"
}

{
  "name": "Check Overdue Reviews",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    SELECT content_id, priority, assigned_at,
           CASE priority
             WHEN 'critical' THEN assigned_at + INTERVAL '2 minutes'
             WHEN 'high' THEN assigned_at + INTERVAL '5 minutes'
             ELSE assigned_at + INTERVAL '15 minutes'
           END as deadline
    FROM content_reviews
    WHERE status = 'pending'
    AND assigned_at < NOW() - INTERVAL '2 minutes'
  `
}

// Escalate overdue items
{
  "name": "Escalate Overdue",
  "type": "n8n-nodes-base.slack",
  "channel": "#mod-supervisors",
  "text": "⏰ {{ $json.length }} content reviews overdue for human review"
}

// Metrics Dashboard Pipeline

// Collect Metrics
{
  "name": "Aggregate Daily Metrics",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    SELECT
      DATE(created_at) as date,
      COUNT(*) as total_requests,
      AVG(EXTRACT(EPOCH FROM (decided_at - created_at))/60) as avg_decision_time_minutes,
      SUM(CASE WHEN ai_recommendation = final_decision THEN 1 ELSE 0 END) * 100.0 / COUNT(*) as ai_human_agreement_pct,
      SUM(CASE WHEN status = 'escalated' THEN 1 ELSE 0 END) * 100.0 / COUNT(*) as escalation_rate_pct,
      AVG(CASE WHEN status = 'escalated' THEN confidence ELSE NULL END) as avg_escalation_confidence
    FROM workflow_decisions
    WHERE created_at >= CURRENT_DATE - INTERVAL '30 days'
    GROUP BY DATE(created_at)
    ORDER BY date DESC
  `
}

// Send to Dashboard
{
  "name": "Update Dashboard",
  "type": "n8n-nodes-base.httpRequest",
  "method": "POST",
  "url": "https://dashboard.example.com/metrics/ingest",
  "body": "={{ $json }}"
}

// Alert on Anomalies
{
  "name": "Check Thresholds",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "number": [
      { "value1": "={{ $json.escalation_rate_pct }}", "operation": "gt", "value2": 20 },
      { "value1": "={{ $json.avg_decision_time_minutes }}", "operation": "gt", "value2": 30 }
    ]
  }
}

{
  "name": "Send Alert",
  "type": "n8n-nodes-base.slack",
  "channel": "#ops-alerts",
  "text": "⚠️ HITL Performance Alert: Escalation rate {{ $json.escalation_rate_pct }}% exceeds threshold"
}

// Comprehensive Audit Logging
{
  "name": "Workflow Audit Log",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "hitl_audit_log",
  "columns": {
    "workflow_id": "={{ $execution.id }}",
    "workflow_name": "={{ $workflow.name }}",
    "trigger_type": "={{ $execution.mode }}",
    "start_time": "={{ $execution.startTime }}",
    "ai_decision": "={{ JSON.stringify($json.ai_recommendation) }}",
    "human_decision": "={{ $json.human_decision }}",
    "decision_maker": "={{ $json.approver_id }}",
    "decision_time": "={{ $now }}",
    "justification": "={{ $json.decision_reason }}",
    "ip_address": "={{ $json.client_ip }}",
    "user_agent": "={{ $json.user_agent }}",
    "compliance_tags": "={{ $json.compliance_requirements }}"
  }
}

// Policy Engine Implementation
{
  "name": "Enforce Business Policies",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const policies = {
      spending_limits: {
        manager: 5000,
        director: 50000,
        vp: 250000
      },
      restricted_vendors: ['vendor-a', 'vendor-b'],
      required_approvers: {
        it_changes: ['security', 'architecture'],
        hr_decisions: ['hr_business_partner', 'legal']
      }
    };
    
    const violations = [];
    
    // Check spending authority
    if ($json.amount > policies.spending_limits[$json.approver_role]) {
      violations.push('Amount exceeds approval authority');
    }
    
    // Check restricted vendors
    if (policies.restricted_vendors.includes($json.vendor_id)) {
      violations.push('Vendor is on restricted list');
    }
    
    // Check required approvers
    const required = policies.required_approvers[$json.decision_type];
    if (required && !required.every(r => $json.approver_roles.includes(r))) {
      violations.push('Missing required approver roles');
    }
    
    if (violations.length > 0) {
      throw new Error(\`Policy violations: \${violations.join(', ')}\`);
    }
    
    return [$json];
  `
}

// Data Retention Management
{
  "name": "Retention Policy Enforcement",
  "type": "n8n-nodes-base.cron",
  "cronExpression": "0 2 * * *"  // Daily at 2 AM
}

{
  "name": "Apply Retention Rules",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    -- Archive completed workflows older than 90 days
    INSERT INTO workflow_archive
    SELECT * FROM workflow_decisions
    WHERE status = 'completed'
    AND decided_at < NOW() - INTERVAL '90 days';
    
    -- Delete PII from archived records after 1 year
    UPDATE workflow_archive
    SET 
      decision_maker = hash(decision_maker),
      requester_email = hash(requester_email),
      sensitive_data = '[REDACTED]'
    WHERE decided_at < NOW() - INTERVAL '1 year';
    
    -- Delete archived records after 7 years
    DELETE FROM workflow_archive
    WHERE decided_at < NOW() - INTERVAL '7 years';
  `
}

// Multi-Stage Approval Workflow

// Define approval chain
const approvalChain = [
  { role: 'direct_manager', weight: 1, timeout: 86400 },
  { role: 'department_head', weight: 2, timeout: 172800, condition: (req) => req.amount > 10000 },
  { role: 'finance_director', weight: 3, timeout: 259200, condition: (req) => req.amount > 50000 },
  { role: 'cfo', weight: 4, timeout: 604800, condition: (req) => req.amount > 250000 }
];

// Sequential execution with n8n
{
  "name": "Stage Approver",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH chain_position AS (
      SELECT current_stage, total_stages
      FROM approval_chains
      WHERE request_id = $1
    ),
    next_approver AS (
      SELECT approver_id, role, timeout_hours
      FROM approval_chain_config
      WHERE chain_id = $2
      AND stage = (SELECT current_stage + 1 FROM chain_position)
    )
    UPDATE approval_chains
    SET current_stage = current_stage + 1,
        current_approver = (SELECT approver_id FROM next_approver),
        stage_deadline = NOW() + (SELECT timeout_hours FROM next_approver) * INTERVAL '1 hour'
    WHERE request_id = $1
    RETURNING *
  `,
  "parameters": ["={{ $json.request_id }}", "={{ $json.chain_id }}"]
}

// Check for chain completion
{
  "name": "Check Completion",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const isComplete = $json.current_stage >= $json.total_stages;
    
    if (isComplete) {
      // Calculate weighted approval score
      const approvals = $json.stage_approvals;
      const totalWeight = approvalChain.reduce((sum, stage) => sum + stage.weight, 0);
      const approvalScore = approvals.reduce((score, approval) => {
        const stage = approvalChain.find(s => s.role === approval.role);
        return score + (approval.decision === 'approved' ? stage.weight : 0);
      }, 0);
      
      $json.final_decision = approvalScore / totalWeight >= 0.75 ? 'approved' : 'rejected';
      $json.approval_score = approvalScore / totalWeight;
    }
    
    return [$json];
  `
}

// Intelligent Routing with n8n
{
  "name": "Analyze Content Context",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "prompt": `
    Analyze this request and identify:
    1. Domain expertise required (technical, financial, legal, etc.)
    2. Urgency level
    3. Stakeholder impact
    4. Regulatory considerations
    
    Return a structured classification.
  `
}

// Match to best approver
{
  "name": "Find Expert Approver",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH expertise_match AS (
      SELECT 
        a.id,
        a.name,
        a.current_workload,
        array_length(ARRAY(
          SELECT unnest(a.expertise_areas)
          INTERSECT
          SELECT unnest($1::text[])
        ), 1) as match_score
      FROM approvers a
      WHERE a.status = 'available'
      AND a.current_workload < a.max_workload
    )
    SELECT id, name, match_score
    FROM expertise_match
    WHERE match_score > 0
    ORDER BY match_score DESC, current_workload ASC
    LIMIT 1
  `,
  "parameters": ["={{ $json.required_expertise }}"]
}

// AI Decision Support
{
  "name": "Generate Decision Support",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "prompt": `
    Given this approval request, provide:
    1. Summary of key points
    2. Comparison with similar past decisions
    3. Risk assessment
    4. Recommended decision with confidence
    5. Key questions approver should consider
  `
}

// Enrich approval request
{
  "name": "Build Approval Package",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const support = await generateDecisionSupport($json);
    const similar = await findSimilarDecisions($json);
    const risk = await assessRisk($json);
    
    return [{
      json: {
        ...$json,
        approval_package: {
          ai_summary: support.summary,
          similar_cases: similar.slice(0, 3),
          risk_assessment: risk,
          recommendation: support.recommendation,
          confidence: support.confidence
        }
      }
    }];
  `
}

// Dynamic Load Balancing
{
  "name": "Monitor Queue Depths",
  "type": "n8n-nodes-base.cron",
  "cronExpression": "*/5 * * * *"  // Every 5 minutes
}

{
  "name": "Check Approver Loads",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    SELECT approver_id, COUNT(*) as queue_depth
    FROM approval_requests
    WHERE status = 'pending'
    GROUP BY approver_id
    HAVING COUNT(*) > 10
  `
}

{
  "name": "Redistribute Load",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    for (const overloaded of $json) {
      // Find underutilized approvers
      const alternatives = await findAvailableApprovers({
        exclude: overloaded.approver_id,
        requiredSkills: overloaded.required_skills
      });
      
      // Reassign oldest items
      await reassignRequests({
        from: overloaded.approver_id,
        to: alternatives[0].id,
        limit: Math.floor(overloaded.queue_depth / 2)
      });
    }
  `
}

// Analyze Decision Patterns
{
  "name": "Decision Divergence Analysis",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH decision_stats AS (
      SELECT
        decision_type,
        ai_recommendation,
        human_decision,
        COUNT(*) as frequency,
        AVG(confidence) as avg_confidence
      FROM approval_decisions
      WHERE created_at > NOW() - INTERVAL '30 days'
      GROUP BY decision_type, ai_recommendation, human_decision
    )
    SELECT
      decision_type,
      ai_recommendation,
      human_decision,
      frequency,
      avg_confidence,
      frequency * 100.0 / SUM(frequency) OVER (PARTITION BY decision_type) as percentage
    FROM decision_stats
    WHERE ai_recommendation != human_decision
    ORDER BY frequency DESC
  `
}

// Timeout Management
{
  "name": "Check Stalled Approvals",
  "type": "n8n-nodes-base.cron",
  "cronExpression": "0 * * * *"  // Hourly
}

{
  "name": "Find Stalled Items",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    SELECT request_id, approver_id, waiting_since, escalation_level
    FROM approval_requests
    WHERE status = 'waiting'
    AND waiting_since < NOW() - INTERVAL '1 hour'
    AND escalation_level < 3
  `
}

{
  "name": "Escalate Stalled Items",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const escalationActions = {
      0: (req) => sendReminder(req.approver_id, req.request_id),
      1: (req) => notifyManager(req.approver_id, req.request_id),
      2: (req) => reassignToBackup(req),
      3: (req) => autoEscalateToNextLevel(req)
    };
    
    for (const request of $json) {
      const action = escalationActions[request.escalation_level];
      await action(request);
      
      // Increment escalation level
      await incrementEscalation(request.request_id);
    }
  `
}

// Predictive Routing
{
  "name": "Pre-Flag for Review",
  "type": "@n8n/n8n-nodes-langchain.agent",
  "prompt": `
    Based on this request's characteristics, predict:
    1. Likelihood of human override (0-100%)
    2. Most common reasons for past overrides in similar cases
    3. Specific aspects approvers typically question
    
    If override likelihood > 70%, recommend preemptive human review.
  `
}

// Dynamic Threshold Adjustment
{
  "name": "Optimize Thresholds",
  "type": "n8n-nodes-base.cron",
  "cronExpression": "0 0 * * 0"  // Weekly
}

{
  "name": "Calculate Optimal Thresholds",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "query": `
    WITH performance_by_threshold AS (
      SELECT
        decision_type,
        confidence_bucket,
        AVG(CASE WHEN ai_decision = human_decision THEN 1 ELSE 0 END) as accuracy,
        COUNT(*) as volume
      FROM decisions
      WHERE created_at > NOW() - INTERVAL '30 days'
      GROUP BY decision_type, FLOOR(confidence * 10) / 10 as confidence_bucket
    )
    SELECT
      decision_type,
      MAX(CASE WHEN accuracy >= 0.95 THEN confidence_bucket END) as optimal_auto_threshold,
      MIN(CASE WHEN accuracy <= 0.70 THEN confidence_bucket END) as required_human_threshold
    FROM performance_by_threshold
    GROUP BY decision_type
  `
}

// Collaborative Decision Framework
{
  "name": "Negotiate Decision",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    // Initial positions
    const aiPosition = await getAIRecommendation($json);
    const humanPosition = await collectHumanInitial($json);
    
    // If agreement, proceed
    if (aiPosition.decision === humanPosition.decision) {
      return { decision: aiPosition.decision, confidence: 'high' };
    }
    
    // Otherwise, facilitate discussion
    const discussion = await facilitateAIDiscussion(aiPosition, humanPosition);
    
    // Synthesize final decision
    return await synthesizeDecision(discussion);
  `
}