Implementation Guide: Track weather forecasts and proactively reschedule outdoor work crews

export VISUAL_CROSSING_API_KEY='your-key-here'

export OPENAI_API_KEY='sk-your-key-here'

export TWILIO_ACCOUNT_SID='your-sid'
export TWILIO_AUTH_TOKEN='your-token'
export TWILIO_PHONE_NUMBER='+1XXXXXXXXXX'

aws rds create-db-instance \
  --db-instance-identifier weather-agent-db \
  --db-instance-class db.t3.micro \
  --engine postgres \
  --engine-version 16.3 \
  --master-username mspadmin \
  --master-user-password '<strong-password>' \
  --allocated-storage 20 \
  --backup-retention-period 30

CREATE TABLE job_sites (
  id SERIAL PRIMARY KEY,
  client_id VARCHAR(50) NOT NULL,
  site_name VARCHAR(255) NOT NULL,
  address TEXT NOT NULL,
  latitude DECIMAL(10, 7),
  longitude DECIMAL(10, 7),
  is_active BOOLEAN DEFAULT true,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE crews (
  id SERIAL PRIMARY KEY,
  crew_name VARCHAR(100) NOT NULL,
  lead_name VARCHAR(100) NOT NULL,
  lead_phone VARCHAR(20) NOT NULL,
  lead_email VARCHAR(255),
  crew_size INTEGER DEFAULT 1,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE schedule_entries (
  id SERIAL PRIMARY KEY,
  job_site_id INTEGER REFERENCES job_sites(id),
  crew_id INTEGER REFERENCES crews(id),
  activity_type VARCHAR(100) NOT NULL,
  is_outdoor_sensitive BOOLEAN DEFAULT true,
  scheduled_date DATE NOT NULL,
  scheduled_start_time TIME,
  scheduled_end_time TIME,
  status VARCHAR(30) DEFAULT 'scheduled',
  external_pm_id VARCHAR(100),
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE weather_thresholds (
  id SERIAL PRIMARY KEY,
  activity_type VARCHAR(100) NOT NULL,
  max_wind_mph DECIMAL(5,1) DEFAULT 25.0,
  max_precip_probability DECIMAL(5,2) DEFAULT 0.50,
  min_temp_f DECIMAL(5,1) DEFAULT 32.0,
  max_temp_f DECIMAL(5,1) DEFAULT 100.0,
  max_heat_index_f DECIMAL(5,1) DEFAULT 90.0,
  lightning_risk_block BOOLEAN DEFAULT true,
  max_snow_inches DECIMAL(5,1) DEFAULT 1.0,
  notes TEXT,
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE weather_checks (
  id SERIAL PRIMARY KEY,
  job_site_id INTEGER REFERENCES job_sites(id),
  check_timestamp TIMESTAMP DEFAULT NOW(),
  forecast_date DATE NOT NULL,
  temperature_f DECIMAL(5,1),
  feels_like_f DECIMAL(5,1),
  wind_speed_mph DECIMAL(5,1),
  wind_gust_mph DECIMAL(5,1),
  precip_probability DECIMAL(5,2),
  precip_type VARCHAR(30),
  snow_inches DECIMAL(5,1),
  humidity DECIMAL(5,1),
  uv_index DECIMAL(4,1),
  conditions VARCHAR(255),
  severe_alerts TEXT,
  raw_api_response JSONB
);

CREATE TABLE reschedule_decisions (
  id SERIAL PRIMARY KEY,
  schedule_entry_id INTEGER REFERENCES schedule_entries(id),
  weather_check_id INTEGER REFERENCES weather_checks(id),
  decision VARCHAR(30) NOT NULL,
  reason TEXT NOT NULL,
  ai_explanation TEXT,
  original_date DATE,
  new_date DATE,
  decided_at TIMESTAMP DEFAULT NOW(),
  confirmed_by_lead BOOLEAN DEFAULT false,
  confirmed_at TIMESTAMP
);

CREATE TABLE notifications (
  id SERIAL PRIMARY KEY,
  reschedule_decision_id INTEGER REFERENCES reschedule_decisions(id),
  recipient_phone VARCHAR(20),
  recipient_name VARCHAR(100),
  message_body TEXT,
  channel VARCHAR(20) DEFAULT 'sms',
  twilio_sid VARCHAR(100),
  delivery_status VARCHAR(30),
  sent_at TIMESTAMP DEFAULT NOW(),
  delivered_at TIMESTAMP
);

-- Insert default weather thresholds
INSERT INTO weather_thresholds (activity_type, max_wind_mph, max_precip_probability, min_temp_f, max_temp_f, max_heat_index_f, lightning_risk_block, notes) VALUES
('concrete_pour', 20.0, 0.40, 40.0, 95.0, 90.0, true, 'Concrete requires strict temperature and moisture control'),
('roofing', 25.0, 0.30, 35.0, 100.0, 95.0, true, 'Wind and rain are primary risks; steep slope work hazardous when wet'),
('exterior_painting', 15.0, 0.20, 50.0, 95.0, 90.0, false, 'Paint requires dry conditions and moderate temps for proper adhesion'),
('grading_excavation', 30.0, 0.50, 20.0, 105.0, 95.0, true, 'Heavy equipment can operate in moderate conditions but not saturated soil'),
('steel_erection', 25.0, 0.40, 20.0, 100.0, 95.0, true, 'Wind is primary concern for crane and steel placement'),
('crane_operations', 20.0, 0.30, 15.0, 105.0, 95.0, true, 'Strict wind limits per crane manufacturer specifications'),
('framing', 30.0, 0.50, 25.0, 100.0, 95.0, true, 'Moderate weather tolerance; lightning is primary safety risk'),
('landscaping', 25.0, 0.40, 35.0, 100.0, 95.0, false, 'Can work in light rain but not heavy precipitation'),
('general_outdoor', 25.0, 0.50, 32.0, 100.0, 90.0, true, 'Default thresholds for unspecified outdoor work');

CREATE INDEX idx_schedule_date ON schedule_entries(scheduled_date);
CREATE INDEX idx_weather_checks_site_date ON weather_checks(job_site_id, forecast_date);
CREATE INDEX idx_decisions_date ON reschedule_decisions(decided_at);

CLIENT_NAME=<client company name>
DEFAULT_TIMEZONE=America/New_York
ALERT_ESCALATION_PHONE=+1XXXXXXXXXX
FORECAST_HOURS_AHEAD=24
POLLING_INTERVAL_HOURS=6

docker volume create n8n_data
docker run -d --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e N8N_BASIC_AUTH_USER=admin \
  -e N8N_BASIC_AUTH_PASSWORD='<strong-password>' \
  -e GENERIC_TIMEZONE='America/New_York' \
  -e N8N_ENCRYPTION_KEY='<generate-random-32-char-string>' \
  --restart unless-stopped \
  n8nio/n8n:latest

\copy job_sites(client_id, site_name, address, latitude, longitude) FROM 'job_sites.csv' WITH CSV HEADER;
\copy crews(crew_name, lead_name, lead_phone, lead_email, crew_size) FROM 'crews.csv' WITH CSV HEADER;

curl -X GET 'https://api.procore.com/rest/v1.0/projects' \
  -H 'Authorization: Bearer <procore_access_token>' \
  -H 'Procore-Company-Id: <company_id>' | jq '.[].name, .[].address'

curl -X POST 'https://api.getjobber.com/api/graphql' \
  -H 'Authorization: Bearer <jobber_access_token>' \
  -H 'Content-Type: application/json' \
  -d '{"query": "{ jobs(first: 50) { nodes { title address { street city state postalCode } } } }"}'

curl 'https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/1234%20Main%20St%20Denver%20CO?key=<API_KEY>&include=current' | jq '.latitude, .longitude'

SELECT id, site_name, latitude, longitude, address FROM job_sites WHERE is_active = true

https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/{{$json.latitude}},{{$json.longitude}}/next3days

key: {{$credentials.vcApiKey}}
unitGroup: us
include: hours,alerts,current
elements: datetime,temp,feelslike,humidity,precip,precipprob,preciptype,snow,windspeed,windgust,uvindex,conditions,description,severerisk

INSERT INTO weather_checks (job_site_id, forecast_date, temperature_f, ...)
  VALUES ($1, $2, $3, ...) RETURNING id

{
  'site_name': 'Oak Ridge Subdivision Lot 14',
  'decision': 'reschedule' | 'proceed' | 'monitor',
  'affected_activities': [...],
  'reason': 'human-readable explanation',
  'risk_level': 'high' | 'medium' | 'low',
  'recommended_reschedule_date': '2025-01-20',
  'osha_heat_alert': true/false,
  'specific_concerns': [...]
}

# [Webhook: SMS Reply Handler]
# URL: https://<n8n-instance>/webhook/twilio-reply

# [Teams Incoming Webhook]
# URL: https://outlook.office.com/webhook/<team-specific-url>

# [Twilio Voice Escalation]
twilio.calls.create({
  to: superintendent_phone,
  from: twilio_number,
  twiml: '<Response><Say>Weather alert: Crew lead for site Oak Ridge has not confirmed schedule change. Please intervene.</Say></Response>'
})

PATCH https://api.procore.com/rest/v1.0/schedule_tasks/{{task_id}}
Authorization: Bearer {{$credentials.procoreToken}}
Procore-Company-Id: {{$env.PROCORE_COMPANY_ID}}

{
  "scheduled_start_date": "{{new_date}}",
  "scheduled_end_date": "{{new_end_date}}",
  "notes": "Rescheduled by Weather Agent: {{reason}}"
}

POST https://api.procore.com/rest/v1.0/projects/{{project_id}}/daily_logs
Authorization: Bearer {{$credentials.procoreToken}}
Procore-Company-Id: {{$env.PROCORE_COMPANY_ID}}

{
  "date": "{{original_date}}",
  "weather_delay": true,
  "notes": "{{ai_explanation}}",
  "weather_conditions": "{{conditions_summary}}"
}

# Reschedule Job (POST to https://api.getjobber.com/api/graphql)

mutation {
  jobReschedule(jobId: "{{jobber_job_id}}", input: {
    startAt: "{{new_datetime_iso}}"
    endAt: "{{new_end_datetime_iso}}"
  }) {
    job { id title startAt endAt }
    userErrors { message }
  }
}

UPDATE weather_thresholds SET
  max_heat_index_f = 80.0
WHERE activity_type IN ('general_outdoor', 'roofing', 'concrete_pour', 'exterior_painting');

INSERT INTO weather_thresholds (activity_type, max_heat_index_f, notes)
VALUES ('cal_osha_outdoor', 80.0, 'Cal/OSHA outdoor heat trigger - mandatory water, shade, rest'),
       ('cal_osha_high_heat', 95.0, 'Cal/OSHA high heat - mandatory buddy system, pre-shift meetings');

const T = $json.temperature_f;
const R = $json.humidity;
let HI = 0.5 * (T + 61.0 + ((T-68.0)*1.2) + (R*0.094));
if (HI >= 80) {
  HI = -42.379 + 2.04901523*T + 10.14333127*R
    - 0.22475541*T*R - 0.00683783*T*T - 0.05481717*R*R
    + 0.00122874*T*T*R + 0.00085282*T*R*R - 0.00000199*T*T*R*R;
}
return [{json: {...$json, heat_index_f: Math.round(HI * 10) / 10}}];

docker run -d --name grafana -p 3000:3000 grafana/grafana-oss:latest

SELECT 
  (SELECT COUNT(*) FROM weather_checks WHERE check_timestamp > NOW() - INTERVAL '24 hours') as checks_24h,
  (SELECT COUNT(*) FROM reschedule_decisions WHERE decided_at > NOW() - INTERVAL '24 hours') as decisions_24h,
  (SELECT COUNT(*) FROM notifications WHERE sent_at > NOW() - INTERVAL '24 hours' AND delivery_status = 'delivered') as notifications_delivered_24h,
  (SELECT COUNT(*) FROM reschedule_decisions WHERE decided_at > NOW() - INTERVAL '24 hours' AND confirmed_by_lead = false) as unconfirmed_24h;

curl 'https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/39.7392,-104.9903/2025-01-15?key=<API_KEY>&unitGroup=us&include=hours' | jq '.days[0].hours[] | {datetime, temp, windspeed, precipprob, conditions}'

INSERT INTO schedule_entries (job_site_id, crew_id, activity_type, is_outdoor_sensitive, scheduled_date, scheduled_start_time, scheduled_end_time, status)
VALUES (1, 1, 'concrete_pour', true, '2025-01-15', '07:00', '15:00', 'scheduled');

SELECT * FROM reschedule_decisions ORDER BY decided_at DESC LIMIT 5;

// n8n Code Node: Weather Forecast Parser
// Input: Raw Visual Crossing API JSON response + schedule entry
// Output: Structured weather assessment for the scheduled work period

const weatherData = $input.first().json;
const scheduleEntries = $('Get Tomorrow Schedules').all();

const results = [];

for (const entry of scheduleEntries) {
  const siteWeather = weatherData;
  const startHour = parseInt(entry.json.scheduled_start_time.split(':')[0]);
  const endHour = parseInt(entry.json.scheduled_end_time.split(':')[0]);
  
  // Filter forecast hours to scheduled work window
  const workHours = siteWeather.days[0].hours.filter(h => {
    const hour = parseInt(h.datetime.split(':')[0]);
    return hour >= startHour && hour <= endHour;
  });
  
  if (workHours.length === 0) {
    results.push({ json: { ...entry.json, weather_assessment: 'NO_DATA', skip: true } });
    continue;
  }
  
  // Calculate aggregated weather metrics for the work window
  const maxTemp = Math.max(...workHours.map(h => h.temp));
  const minTemp = Math.min(...workHours.map(h => h.temp));
  const maxFeelsLike = Math.max(...workHours.map(h => h.feelslike));
  const maxWind = Math.max(...workHours.map(h => h.windspeed));
  const maxGust = Math.max(...workHours.map(h => h.windgust || h.windspeed));
  const maxPrecipProb = Math.max(...workHours.map(h => h.precipprob)) / 100;
  const avgHumidity = workHours.reduce((sum, h) => sum + h.humidity, 0) / workHours.length;
  const maxUV = Math.max(...workHours.map(h => h.uvindex || 0));
  const totalSnow = workHours.reduce((sum, h) => sum + (h.snow || 0), 0);
  const precipTypes = [...new Set(workHours.flatMap(h => h.preciptype || []))];
  const severeRisk = Math.max(...workHours.map(h => h.severerisk || 0));
  
  // Calculate Heat Index (Rothfusz regression)
  function calcHeatIndex(T, R) {
    let HI = 0.5 * (T + 61.0 + ((T - 68.0) * 1.2) + (R * 0.094));
    if (HI >= 80) {
      HI = -42.379 + 2.04901523 * T + 10.14333127 * R
        - 0.22475541 * T * R - 0.00683783 * T * T
        - 0.05481717 * R * R + 0.00122874 * T * T * R
        + 0.00085282 * T * R * R - 0.00000199 * T * T * R * R;
      // Adjustment for low humidity
      if (R < 13 && T >= 80 && T <= 112) {
        HI -= ((13 - R) / 4) * Math.sqrt((17 - Math.abs(T - 95)) / 17);
      }
      // Adjustment for high humidity
      if (R > 85 && T >= 80 && T <= 87) {
        HI += ((R - 85) / 10) * ((87 - T) / 5);
      }
    }
    return Math.round(HI * 10) / 10;
  }
  
  const maxHeatIndex = calcHeatIndex(maxTemp, avgHumidity);
  
  // Identify worst weather window
  const worstHour = workHours.reduce((worst, h) => {
    const score = (h.precipprob / 100) * 3 + (h.windspeed / 50) * 2 + ((h.severerisk || 0) / 100) * 5;
    const worstScore = (worst.precipprob / 100) * 3 + (worst.windspeed / 50) * 2 + ((worst.severerisk || 0) / 100) * 5;
    return score > worstScore ? h : worst;
  });
  
  // Compile conditions summary
  const conditions = [...new Set(workHours.map(h => h.conditions))].join(', ');
  
  results.push({
    json: {
      schedule_entry_id: entry.json.id,
      job_site_id: entry.json.job_site_id,
      site_name: entry.json.site_name,
      crew_id: entry.json.crew_id,
      crew_name: entry.json.crew_name,
      activity_type: entry.json.activity_type,
      is_outdoor_sensitive: entry.json.is_outdoor_sensitive,
      scheduled_date: entry.json.scheduled_date,
      work_window: `${entry.json.scheduled_start_time} - ${entry.json.scheduled_end_time}`,
      weather: {
        max_temp_f: maxTemp,
        min_temp_f: minTemp,
        max_feels_like_f: maxFeelsLike,
        max_heat_index_f: maxHeatIndex,
        max_wind_mph: maxWind,
        max_gust_mph: maxGust,
        max_precip_probability: maxPrecipProb,
        precip_types: precipTypes,
        total_snow_inches: totalSnow,
        avg_humidity: Math.round(avgHumidity),
        max_uv_index: maxUV,
        severe_risk_pct: severeRisk,
        conditions_summary: conditions,
        worst_hour: worstHour.datetime,
        worst_hour_conditions: worstHour.conditions
      },
      skip: false
    }
  });
}

return results;

// configure system prompt in n8n OpenAI node > System Message; user prompt
// is built dynamically in the n8n Code node

// SYSTEM PROMPT (configure in n8n OpenAI node > System Message)

const systemPrompt = `You are an autonomous weather safety and scheduling agent for a construction company. Your job is to evaluate weather forecasts against scheduled outdoor work and make intelligent rescheduling decisions.

## Your Decision Framework

For each scheduled activity, you must evaluate the weather forecast and return ONE of these decisions:

1. **PROCEED** - Weather is within safe thresholds. Work should continue as scheduled.
2. **MONITOR** - Weather is borderline. Work can start but crew lead should monitor conditions and be prepared to stop. Send advisory notice.
3. **RESCHEDULE** - Weather will prevent safe or productive work. Reschedule to the next available clear day.
4. **STOP_WORK_HEAT** - OSHA heat illness risk. Mandatory hydration, shade, and rest protocols. May require shortened work day or full reschedule.
5. **STOP_WORK_SEVERE** - Severe weather (lightning, tornado, extreme wind). Immediate safety stand-down required.

## Activity-Specific Thresholds

You will receive the applicable thresholds for each activity type. Use these as your primary decision criteria:
- If ANY threshold is exceeded during the scheduled work window, the activity should be rescheduled
- If thresholds are within 10% of being exceeded, issue a MONITOR advisory
- Lightning risk or severe weather alerts ALWAYS trigger STOP_WORK_SEVERE regardless of other conditions

## OSHA Heat Compliance Rules (MANDATORY)
- Heat Index >= 80°F: Recommend water breaks every 20 minutes, provide shade access
- Heat Index >= 90°F: STOP_WORK_HEAT - Mandatory rest/water schedule, buddy system required
- Heat Index >= 105°F: STOP_WORK_HEAT - Cease all outdoor work immediately

## Rescheduling Logic
When recommending a reschedule:
- Look at the next 3-5 calendar days of forecast data if available
- Recommend the nearest day where ALL thresholds are met
- If no clear day in the next 5 days, recommend the best available day and note the compromise
- Consider task dependencies: concrete pours need 2+ consecutive dry days for curing
- Prioritize: safety first, then productivity, then schedule impact

## Output Format
Always respond with valid JSON matching this exact schema:
{
  "decisions": [
    {
      "schedule_entry_id": <integer>,
      "site_name": "<string>",
      "activity_type": "<string>",
      "decision": "PROCEED" | "MONITOR" | "RESCHEDULE" | "STOP_WORK_HEAT" | "STOP_WORK_SEVERE",
      "risk_level": "low" | "medium" | "high" | "critical",
      "primary_concerns": ["<list of specific weather concerns>"],
      "reason": "<2-3 sentence plain-English explanation suitable for sending to a crew foreman via text message>",
      "recommended_new_date": "<YYYY-MM-DD or null if PROCEED>",
      "osha_heat_alert": <boolean>,
      "osha_heat_details": "<specific heat precautions required, or null>",
      "confidence": <0.0 to 1.0>
    }
  ],
  "overall_summary": "<1-2 sentence summary of all decisions for the office manager>"
}

## Safety Rules
- When in doubt, err on the side of caution (RESCHEDULE over PROCEED)
- Never recommend proceeding with work during lightning risk
- Always flag heat index concerns even if other conditions are favorable
- If forecast data seems incomplete or unreliable, recommend MONITOR and flag the data quality issue
`;

// USER PROMPT TEMPLATE (constructed dynamically per evaluation batch)
// This is built in the n8n Code node that prepares the AI context

function buildUserPrompt(weatherAssessments, thresholds, forecastDays) {
  let prompt = `## Current Evaluation Batch\n`;
  prompt += `Evaluation Time: ${new Date().toISOString()}\n`;
  prompt += `Client: {{$env.CLIENT_NAME}}\n\n`;
  
  for (const assessment of weatherAssessments) {
    prompt += `### Scheduled Activity\n`;
    prompt += `- Schedule Entry ID: ${assessment.schedule_entry_id}\n`;
    prompt += `- Site: ${assessment.site_name}\n`;
    prompt += `- Activity: ${assessment.activity_type}\n`;
    prompt += `- Crew: ${assessment.crew_name}\n`;
    prompt += `- Date: ${assessment.scheduled_date}\n`;
    prompt += `- Work Window: ${assessment.work_window}\n`;
    prompt += `- Outdoor Sensitive: ${assessment.is_outdoor_sensitive}\n\n`;
    
    // Get matching thresholds
    const t = thresholds.find(th => th.activity_type === assessment.activity_type) 
      || thresholds.find(th => th.activity_type === 'general_outdoor');
    
    prompt += `#### Applicable Thresholds for ${assessment.activity_type}\n`;
    prompt += `- Max Wind: ${t.max_wind_mph} mph\n`;
    prompt += `- Max Precip Probability: ${(t.max_precip_probability * 100).toFixed(0)}%\n`;
    prompt += `- Min Temperature: ${t.min_temp_f}°F\n`;
    prompt += `- Max Temperature: ${t.max_temp_f}°F\n`;
    prompt += `- Max Heat Index: ${t.max_heat_index_f}°F\n`;
    prompt += `- Lightning Blocks Work: ${t.lightning_risk_block}\n`;
    prompt += `- Max Snow: ${t.max_snow_inches} inches\n\n`;
    
    prompt += `#### Weather Forecast for Work Window\n`;
    prompt += `- Max Temperature: ${assessment.weather.max_temp_f}°F\n`;
    prompt += `- Min Temperature: ${assessment.weather.min_temp_f}°F\n`;
    prompt += `- Max Feels Like: ${assessment.weather.max_feels_like_f}°F\n`;
    prompt += `- Calculated Heat Index: ${assessment.weather.max_heat_index_f}°F\n`;
    prompt += `- Max Wind Speed: ${assessment.weather.max_wind_mph} mph\n`;
    prompt += `- Max Wind Gust: ${assessment.weather.max_gust_mph} mph\n`;
    prompt += `- Max Precipitation Probability: ${(assessment.weather.max_precip_probability * 100).toFixed(0)}%\n`;
    prompt += `- Precipitation Types: ${assessment.weather.precip_types.join(', ') || 'None'}\n`;
    prompt += `- Total Snow: ${assessment.weather.total_snow_inches} inches\n`;
    prompt += `- Humidity: ${assessment.weather.avg_humidity}%\n`;
    prompt += `- UV Index: ${assessment.weather.max_uv_index}\n`;
    prompt += `- Severe Risk: ${assessment.weather.severe_risk_pct}%\n`;
    prompt += `- Conditions: ${assessment.weather.conditions_summary}\n`;
    prompt += `- Worst Hour: ${assessment.weather.worst_hour} — ${assessment.weather.worst_hour_conditions}\n\n`;
  }
  
  if (forecastDays && forecastDays.length > 0) {
    prompt += `### Extended Forecast (for rescheduling suggestions)\n`;
    for (const day of forecastDays) {
      prompt += `- ${day.date}: High ${day.high}°F, Low ${day.low}°F, Wind ${day.wind} mph, Precip ${day.precip_prob}%, Conditions: ${day.conditions}\n`;
    }
    prompt += `\n`;
  }
  
  prompt += `Please evaluate all scheduled activities above and return your decisions as JSON.`;
  return prompt;
}

// Export for use in n8n
return { systemPrompt, buildUserPrompt };

// n8n Code Node: SMS Notification Composer
// Input: reschedule decision object
// Output: formatted SMS message body per recipient type

const decision = $input.first().json;

function composeCrewLeadSMS(d) {
  switch (d.decision) {
    case 'PROCEED':
      return null; // No notification needed for proceed
      
    case 'MONITOR':
      return `⚠️ WEATHER ADVISORY\n${d.site_name}\n${d.scheduled_date}\nConditions may change: ${d.primary_concerns.join(', ')}\n${d.reason}\nMonitor conditions & be ready to stop. Reply OK to confirm.`;
      
    case 'RESCHEDULE':
      return `🔄 SCHEDULE CHANGE\n${d.site_name}\n${d.activity_type} moved from ${d.scheduled_date} to ${d.recommended_new_date}\nReason: ${d.reason}\nReply OK to confirm or CALL to discuss.`;
      
    case 'STOP_WORK_HEAT':
      return `🔴 HEAT ALERT - ${d.site_name}\nHeat index forecast: DANGEROUS\n${d.osha_heat_details}\nActivity: ${d.activity_type}\nDate: ${d.scheduled_date}\n${d.reason}\nReply OK to confirm. OSHA compliance required.`;
      
    case 'STOP_WORK_SEVERE':
      return `🚨 SEVERE WEATHER - STOP WORK\n${d.site_name}\n${d.primary_concerns.join(', ')}\n${d.reason}\nDO NOT send crews. Reply OK to confirm.`;
      
    default:
      return `Weather update for ${d.site_name}: ${d.reason}. Reply OK to confirm.`;
  }
}

function composeWorkerSMS(d) {
  // Shorter messages for individual workers
  switch (d.decision) {
    case 'RESCHEDULE':
      return `Schedule change: ${d.activity_type} at ${d.site_name} moved to ${d.recommended_new_date}. Contact your crew lead for details.`;
      
    case 'STOP_WORK_HEAT':
      return `⚠️ HEAT ALERT: ${d.site_name} on ${d.scheduled_date}. ${d.osha_heat_details} Contact your crew lead.`;
      
    case 'STOP_WORK_SEVERE':
      return `🚨 SEVERE WEATHER: Do not report to ${d.site_name} on ${d.scheduled_date}. Stay safe. Contact crew lead for updates.`;
      
    default:
      return null;
  }
}

function composeOfficeEmail(d) {
  return {
    subject: `[Weather Agent] ${d.decision}: ${d.site_name} - ${d.scheduled_date}`,
    body: `Weather Rescheduling Decision\n\nSite: ${d.site_name}\nActivity: ${d.activity_type}\nOriginal Date: ${d.scheduled_date}\nDecision: ${d.decision}\nNew Date: ${d.recommended_new_date || 'N/A'}\nRisk Level: ${d.risk_level}\n\nReason: ${d.reason}\n\nConcerns: ${d.primary_concerns.join(', ')}\n\nOSHA Heat Alert: ${d.osha_heat_alert ? 'YES - ' + d.osha_heat_details : 'No'}\n\nConfidence: ${(d.confidence * 100).toFixed(0)}%\n\n---\nThis decision was generated automatically by the Weather Rescheduling Agent.\nWeather data source: Visual Crossing API\nDecision engine: GPT-4.1-mini\nTimestamp: ${new Date().toISOString()}`
  };
}

function composeTeamsCard(d) {
  const colorMap = {
    'PROCEED': '00FF00',
    'MONITOR': 'FFA500',
    'RESCHEDULE': 'FF8C00',
    'STOP_WORK_HEAT': 'FF4500',
    'STOP_WORK_SEVERE': 'FF0000'
  };
  
  return {
    '@type': 'MessageCard',
    '@context': 'http://schema.org/extensions',
    'themeColor': colorMap[d.decision] || '808080',
    'summary': `Weather ${d.decision}: ${d.site_name}`,
    'sections': [{
      'activityTitle': `${d.decision === 'STOP_WORK_SEVERE' ? '🚨' : d.decision === 'STOP_WORK_HEAT' ? '🔴' : d.decision === 'RESCHEDULE' ? '🔄' : '⚠️'} Weather ${d.decision}`,
      'activitySubtitle': d.site_name,
      'facts': [
        { 'name': 'Activity', 'value': d.activity_type },
        { 'name': 'Date', 'value': d.scheduled_date },
        { 'name': 'New Date', 'value': d.recommended_new_date || 'N/A' },
        { 'name': 'Risk Level', 'value': d.risk_level.toUpperCase() },
        { 'name': 'Concerns', 'value': d.primary_concerns.join(', ') },
        { 'name': 'OSHA Heat', 'value': d.osha_heat_alert ? '⚠️ YES' : 'No' }
      ],
      'text': d.reason
    }]
  };
}

const crewLeadMsg = composeCrewLeadSMS(decision);
const workerMsg = composeWorkerSMS(decision);
const emailContent = composeOfficeEmail(decision);
const teamsCard = composeTeamsCard(decision);

return [{
  json: {
    ...decision,
    notifications: {
      crew_lead_sms: crewLeadMsg,
      worker_sms: workerMsg,
      office_email: emailContent,
      teams_card: teamsCard
    }
  }
}];

const body = $input.first().json.body || $input.first().json;
const fromPhone = (body.From || '').replace(/[^0-9+]/g, '');
const messageBody = (body.Body || '').trim().toUpperCase();
const messageSid = body.MessageSid || '';

// Fuzzy match confirmation responses
const confirmPatterns = ['OK', 'YES', 'CONFIRM', 'CONFIRMED', 'GOT IT', 'ROGER', 'COPY', 'ACK', '10-4', 'SOUNDS GOOD', 'WILL DO', 'K', 'YEP', 'YUP', 'SURE'];
const rejectPatterns = ['NO', 'REJECT', 'CALL', 'CALL ME', 'DISAGREE', 'PROBLEM', 'ISSUE', 'WRONG', 'CANT', "CAN'T"];

const isConfirm = confirmPatterns.some(p => messageBody.includes(p));
const isReject = rejectPatterns.some(p => messageBody.includes(p));

let action = 'unknown';
let replyText = '';

if (isConfirm) {
  action = 'confirmed';
  replyText = 'Schedule change confirmed. Stay safe out there! 👷';
} else if (isReject) {
  action = 'rejected';
  replyText = 'Got it. Escalating to your superintendent now. They will call you shortly.';
} else {
  action = 'unclear';
  replyText = 'Sorry, I didn\'t understand. Reply OK to confirm the schedule change, or CALL to speak with your superintendent.';
}

// Return data for downstream processing
const result = {
  from_phone: fromPhone,
  message_body: messageBody,
  message_sid: messageSid,
  action: action,
  reply_twiml: `<?xml version="1.0" encoding="UTF-8"?><Response><Message>${replyText}</Message></Response>`
};

return [{ json: result }];

-- reschedule_decisions confirmation

UPDATE reschedule_decisions
SET confirmed_by_lead = true, confirmed_at = NOW()
WHERE id = (
  SELECT rd.id FROM reschedule_decisions rd
  JOIN notifications n ON n.reschedule_decision_id = rd.id
  WHERE n.recipient_phone = $1
  AND rd.confirmed_by_lead = false
  ORDER BY rd.decided_at DESC LIMIT 1
);

SELECT * FROM reschedule_decisions
  WHERE confirmed_by_lead = false
  AND decided_at < NOW() - INTERVAL '30 minutes'
  AND decided_at > NOW() - INTERVAL '31 minutes';

SELECT * FROM reschedule_decisions
  WHERE confirmed_by_lead = false
  AND decided_at < NOW() - INTERVAL '60 minutes'
  AND decided_at > NOW() - INTERVAL '61 minutes';

<Response><Say voice="alice">Attention: Weather alert for site {site_name}. Crew lead {lead_name} has not confirmed the schedule change made {minutes} minutes ago. The original activity was {activity_type} scheduled for {date}. Please contact the crew lead at {phone} or call the office.</Say></Response>

SELECT rd.*, se.activity_type, se.scheduled_date,
  js.site_name, js.address,
  wc.temperature_f, wc.wind_speed_mph, wc.precip_probability,
  wc.conditions, wc.raw_api_response,
  c.crew_name, c.lead_name,
  n.delivery_status, n.sent_at
FROM reschedule_decisions rd
JOIN schedule_entries se ON rd.schedule_entry_id = se.id
JOIN job_sites js ON se.job_site_id = js.id
JOIN weather_checks wc ON rd.weather_check_id = wc.id
JOIN crews c ON se.crew_id = c.id
LEFT JOIN notifications n ON n.reschedule_decision_id = rd.id
WHERE rd.decided_at::date = CURRENT_DATE
AND rd.decision IN ('RESCHEDULE', 'STOP_WORK_HEAT', 'STOP_WORK_SEVERE')
ORDER BY rd.decided_at;

const decisions = $input.all();
const today = new Date().toLocaleDateString('en-US', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
const clientName = $env.CLIENT_NAME || 'Client';

let html = `
<html><head><style>
  body { font-family: Arial, sans-serif; margin: 40px; color: #333; }
  h1 { color: #1a5276; border-bottom: 2px solid #1a5276; padding-bottom: 10px; }
  h2 { color: #2c3e50; margin-top: 30px; }
  table { border-collapse: collapse; width: 100%; margin: 15px 0; }
  th, td { border: 1px solid #ddd; padding: 8px 12px; text-align: left; }
  th { background-color: #1a5276; color: white; }
  .reschedule { background-color: #fff3cd; }
  .heat { background-color: #f8d7da; }
  .severe { background-color: #f5c6cb; }
  .footer { margin-top: 40px; font-size: 0.85em; color: #666; border-top: 1px solid #ccc; padding-top: 10px; }
</style></head><body>
<h1>Weather Delay Report</h1>
<p><strong>Company:</strong> ${clientName}</p>
<p><strong>Date:</strong> ${today}</p>
<p><strong>Total Weather Decisions:</strong> ${decisions.length}</p>
<p><strong>Report Generated:</strong> ${new Date().toISOString()}</p>

<h2>Delay Summary</h2>
<table>
  <tr><th>#</th><th>Site</th><th>Activity</th><th>Decision</th><th>Original Date</th><th>New Date</th><th>Crew</th><th>Confirmed</th></tr>
`;

decisions.forEach((d, i) => {
  const rowClass = d.json.decision === 'STOP_WORK_SEVERE' ? 'severe' : d.json.decision === 'STOP_WORK_HEAT' ? 'heat' : 'reschedule';
  html += `<tr class="${rowClass}">
    <td>${i+1}</td><td>${d.json.site_name}</td><td>${d.json.activity_type}</td>
    <td>${d.json.decision}</td><td>${d.json.original_date}</td><td>${d.json.new_date || 'TBD'}</td>
    <td>${d.json.crew_name} (${d.json.lead_name})</td><td>${d.json.confirmed_by_lead ? 'Yes' : 'Pending'}</td>
  </tr>`;
});

html += `</table>\n<h2>Weather Conditions Detail</h2>`;

decisions.forEach((d, i) => {
  html += `
  <h3>${i+1}. ${d.json.site_name} — ${d.json.activity_type}</h3>
  <p><strong>Location:</strong> ${d.json.address}</p>
  <p><strong>Conditions:</strong> ${d.json.conditions}</p>
  <p><strong>Temperature:</strong> ${d.json.temperature_f}°F | <strong>Wind:</strong> ${d.json.wind_speed_mph} mph | <strong>Precip Probability:</strong> ${(d.json.precip_probability * 100).toFixed(0)}%</p>
  <p><strong>AI Assessment:</strong> ${d.json.reason}</p>
  <p><strong>Notification Sent:</strong> ${d.json.sent_at || 'N/A'} | <strong>Delivery Status:</strong> ${d.json.delivery_status || 'N/A'}</p>
  `;
});

html += `
<div class="footer">
  <p>This report was automatically generated by the Weather Rescheduling Agent. Weather data sourced from Visual Crossing API (forecast data, not observations). Decisions made by GPT-4.1-mini AI model with human confirmation required. This document is intended to support weather delay claims under AIA A201-2017 §8.3.1 and ConsensusDocs 200 §6.3.</p>
  <p>Retain this document for the project duration plus applicable retention period (typically 6-10 years).</p>
</div>
</body></html>`;

return [{ json: { html_report: html, filename: `weather-delay-report-${new Date().toISOString().split('T')[0]}.html` } }];

INSERT INTO delay_reports (report_date, report_html, decision_count) VALUES (...)

// n8n Code Node: Intelligent Reschedule Date Finder
// Input: activity_type, job_site coordinates, current thresholds, next 7 days forecast
// Output: recommended_date with confidence score and reasoning

const activity = $input.first().json;
const thresholds = $('Get Thresholds').first().json;
const forecast = $('Get Extended Forecast').first().json; // Visual Crossing 7-day forecast

// Activity-specific requirements
const activityRequirements = {
  'concrete_pour': { consecutive_dry_days: 2, min_temp_window_hours: 8, notes: 'Needs dry curing period after pour' },
  'exterior_painting': { consecutive_dry_days: 1, min_temp_window_hours: 6, notes: 'Paint needs dry time; humidity < 85%' },
  'roofing': { consecutive_dry_days: 1, min_temp_window_hours: 4, notes: 'Roof must be dry for safety' },
  'grading_excavation': { consecutive_dry_days: 1, min_temp_window_hours: 6, notes: 'Soil must not be saturated' },
  'steel_erection': { consecutive_dry_days: 0, min_temp_window_hours: 4, notes: 'Primarily wind-dependent' },
  'crane_operations': { consecutive_dry_days: 0, min_temp_window_hours: 4, notes: 'Strictly wind-limited' },
  'framing': { consecutive_dry_days: 0, min_temp_window_hours: 6, notes: 'Can work in light conditions' },
  'landscaping': { consecutive_dry_days: 0, min_temp_window_hours: 4, notes: 'Moderate tolerance' },
  'general_outdoor': { consecutive_dry_days: 0, min_temp_window_hours: 6, notes: 'Default requirements' }
};

const requirements = activityRequirements[activity.activity_type] || activityRequirements['general_outdoor'];

function evaluateDay(dayForecast) {
  const hours = dayForecast.hours || [];
  const workHours = hours.filter(h => {
    const hour = parseInt(h.datetime.split(':')[0]);
    return hour >= 7 && hour <= 17; // 7 AM to 5 PM work window
  });
  
  if (workHours.length === 0) return { suitable: false, score: 0, reason: 'No forecast data for work hours' };
  
  const maxWind = Math.max(...workHours.map(h => h.windspeed || 0));
  const maxPrecipProb = Math.max(...workHours.map(h => (h.precipprob || 0) / 100));
  const maxTemp = Math.max(...workHours.map(h => h.temp || 70));
  const minTemp = Math.min(...workHours.map(h => h.temp || 70));
  const maxGust = Math.max(...workHours.map(h => h.windgust || h.windspeed || 0));
  const severeRisk = Math.max(...workHours.map(h => h.severerisk || 0));
  const avgHumidity = workHours.reduce((s, h) => s + (h.humidity || 50), 0) / workHours.length;
  
  // Calculate heat index
  let HI = 0.5 * (maxTemp + 61.0 + ((maxTemp - 68.0) * 1.2) + (avgHumidity * 0.094));
  if (HI >= 80) {
    HI = -42.379 + 2.04901523*maxTemp + 10.14333127*avgHumidity
      - 0.22475541*maxTemp*avgHumidity - 0.00683783*maxTemp*maxTemp
      - 0.05481717*avgHumidity*avgHumidity + 0.00122874*maxTemp*maxTemp*avgHumidity
      + 0.00085282*maxTemp*avgHumidity*avgHumidity - 0.00000199*maxTemp*maxTemp*avgHumidity*avgHumidity;
  }
  
  const issues = [];
  let score = 100;
  
  if (maxWind > thresholds.max_wind_mph) { issues.push(`Wind ${maxWind.toFixed(0)} mph exceeds ${thresholds.max_wind_mph} mph limit`); score -= 30; }
  if (maxPrecipProb > thresholds.max_precip_probability) { issues.push(`${(maxPrecipProb*100).toFixed(0)}% precip probability exceeds ${(thresholds.max_precip_probability*100).toFixed(0)}% limit`); score -= 30; }
  if (maxTemp > thresholds.max_temp_f) { issues.push(`High temp ${maxTemp.toFixed(0)}°F exceeds ${thresholds.max_temp_f}°F limit`); score -= 25; }
  if (minTemp < thresholds.min_temp_f) { issues.push(`Low temp ${minTemp.toFixed(0)}°F below ${thresholds.min_temp_f}°F minimum`); score -= 25; }
  if (HI > thresholds.max_heat_index_f) { issues.push(`Heat index ${HI.toFixed(0)}°F exceeds ${thresholds.max_heat_index_f}°F OSHA limit`); score -= 35; }
  if (severeRisk > 30) { issues.push(`Severe weather risk: ${severeRisk}%`); score -= 40; }
  
  // Bonus points for ideal conditions
  if (maxPrecipProb < 0.10) score += 5;
  if (maxWind < thresholds.max_wind_mph * 0.5) score += 5;
  if (maxTemp > 55 && maxTemp < 85) score += 5; // Comfortable range
  
  score = Math.max(0, Math.min(100, score));
  
  return {
    date: dayForecast.datetime,
    suitable: issues.length === 0,
    score: score,
    issues: issues,
    conditions: {
      max_temp: maxTemp,
      min_temp: minTemp,
      heat_index: Math.round(HI),
      max_wind: maxWind,
      max_gust: maxGust,
      precip_prob: maxPrecipProb,
      conditions: dayForecast.conditions || 'Unknown'
    }
  };
}

// Evaluate each day in the forecast
const days = forecast.days || [];
const evaluations = days.map(evaluateDay);

// Check consecutive dry day requirements
if (requirements.consecutive_dry_days > 1) {
  for (let i = 0; i < evaluations.length; i++) {
    if (evaluations[i].suitable) {
      let consecutiveDry = 1;
      for (let j = i + 1; j < Math.min(i + requirements.consecutive_dry_days, evaluations.length); j++) {
        if (evaluations[j].conditions.precip_prob < 0.30) consecutiveDry++;
      }
      if (consecutiveDry < requirements.consecutive_dry_days) {
        evaluations[i].suitable = false;
        evaluations[i].issues.push(`Needs ${requirements.consecutive_dry_days} consecutive dry days but only found ${consecutiveDry}`);
        evaluations[i].score -= 20;
      }
    }
  }
}

// Find best day (skip today and original date)
const candidates = evaluations
  .filter(e => e.date !== activity.scheduled_date)
  .sort((a, b) => b.score - a.score);

const bestDay = candidates[0];
const isIdeal = bestDay && bestDay.suitable;

return [{
  json: {
    recommended_date: bestDay ? bestDay.date : null,
    confidence: bestDay ? bestDay.score / 100 : 0,
    is_ideal: isIdeal,
    reason: bestDay ? 
      (isIdeal ? `${bestDay.date} has clear conditions: ${bestDay.conditions.conditions}, high ${bestDay.conditions.max_temp}°F, wind ${bestDay.conditions.max_wind} mph.` :
       `${bestDay.date} is the best available option (score: ${bestDay.score}/100) but has concerns: ${bestDay.issues.join('; ')}.`) :
      'No suitable day found in the 7-day forecast. Manual scheduling required.',
    all_evaluations: evaluations,
    activity_requirements: requirements
  }
}];

// n8n Code Node: Threshold Fallback Decision Engine
// Used when OpenAI API call fails (error handler path)
// Input: weather assessment + thresholds
// Output: decision object matching the AI decision schema

const assessment = $input.first().json;
const w = assessment.weather;

// Get thresholds for this activity type
const thresholdsAll = $('Get Thresholds').all();
const t = thresholdsAll.find(th => th.json.activity_type === assessment.activity_type)?.json
  || thresholdsAll.find(th => th.json.activity_type === 'general_outdoor')?.json;

if (!t) {
  return [{ json: { ...assessment, decision: 'MONITOR', reason: 'Unable to evaluate: no thresholds found. AI API unavailable. Please check weather manually.', risk_level: 'medium', fallback: true } }];
}

const concerns = [];
let decision = 'PROCEED';
let riskLevel = 'low';
let oshaHeatAlert = false;
let oshaDetails = null;

// Check severe weather first (highest priority)
if (w.severe_risk_pct > 50) {
  decision = 'STOP_WORK_SEVERE';
  riskLevel = 'critical';
  concerns.push(`Severe weather risk at ${w.severe_risk_pct}%`);
}

// Check lightning
if (w.conditions_summary && (w.conditions_summary.toLowerCase().includes('thunder') || w.conditions_summary.toLowerCase().includes('lightning'))) {
  if (t.lightning_risk_block) {
    decision = 'STOP_WORK_SEVERE';
    riskLevel = 'critical';
    concerns.push('Lightning/thunderstorm risk detected');
  }
}

// Check OSHA heat
if (w.max_heat_index_f >= 105) {
  decision = 'STOP_WORK_HEAT';
  riskLevel = 'critical';
  oshaHeatAlert = true;
  oshaDetails = 'CEASE ALL OUTDOOR WORK. Heat index 105°F+. Extreme danger of heat stroke.';
  concerns.push(`Extreme heat index: ${w.max_heat_index_f}°F`);
} else if (w.max_heat_index_f >= 90) {
  decision = decision === 'PROCEED' ? 'STOP_WORK_HEAT' : decision;
  riskLevel = riskLevel === 'low' ? 'high' : riskLevel;
  oshaHeatAlert = true;
  oshaDetails = 'Mandatory: Water every 20 min, shade access, buddy system, pre-shift safety meeting.';
  concerns.push(`High heat index: ${w.max_heat_index_f}°F`);
} else if (w.max_heat_index_f >= 80) {
  if (decision === 'PROCEED') decision = 'MONITOR';
  oshaHeatAlert = true;
  oshaDetails = 'Ensure water and shade available. Monitor workers for heat illness symptoms.';
  concerns.push(`Elevated heat index: ${w.max_heat_index_f}°F`);
}

// Check precipitation
if (w.max_precip_probability > t.max_precip_probability) {
  if (decision === 'PROCEED' || decision === 'MONITOR') decision = 'RESCHEDULE';
  if (riskLevel === 'low') riskLevel = 'medium';
  concerns.push(`Precipitation ${(w.max_precip_probability * 100).toFixed(0)}% exceeds ${(t.max_precip_probability * 100).toFixed(0)}% limit`);
} else if (w.max_precip_probability > t.max_precip_probability * 0.8) {
  if (decision === 'PROCEED') decision = 'MONITOR';
  concerns.push(`Precipitation ${(w.max_precip_probability * 100).toFixed(0)}% approaching ${(t.max_precip_probability * 100).toFixed(0)}% limit`);
}

// Check wind
if (w.max_wind_mph > t.max_wind_mph) {
  if (decision === 'PROCEED' || decision === 'MONITOR') decision = 'RESCHEDULE';
  if (riskLevel === 'low') riskLevel = 'medium';
  concerns.push(`Wind ${w.max_wind_mph} mph exceeds ${t.max_wind_mph} mph limit`);
}

// Check temperature
if (w.min_temp_f < t.min_temp_f) {
  if (decision === 'PROCEED' || decision === 'MONITOR') decision = 'RESCHEDULE';
  concerns.push(`Low temp ${w.min_temp_f}°F below ${t.min_temp_f}°F minimum`);
}
if (w.max_temp_f > t.max_temp_f) {
  if (decision === 'PROCEED' || decision === 'MONITOR') decision = 'RESCHEDULE';
  concerns.push(`High temp ${w.max_temp_f}°F exceeds ${t.max_temp_f}°F limit`);
}

// Check snow
if (w.total_snow_inches > (t.max_snow_inches || 1.0)) {
  if (decision === 'PROCEED' || decision === 'MONITOR') decision = 'RESCHEDULE';
  concerns.push(`Snow ${w.total_snow_inches}" exceeds ${t.max_snow_inches}" limit`);
}

const reason = concerns.length > 0 
  ? `[AUTO-FALLBACK] Weather concerns for ${assessment.activity_type} at ${assessment.site_name}: ${concerns.join('. ')}.`
  : `[AUTO-FALLBACK] Weather conditions are within acceptable thresholds for ${assessment.activity_type}.`;

return [{
  json: {
    schedule_entry_id: assessment.schedule_entry_id,
    site_name: assessment.site_name,
    activity_type: assessment.activity_type,
    decision: decision,
    risk_level: riskLevel,
    primary_concerns: concerns,
    reason: reason,
    recommended_new_date: null, // Fallback cannot evaluate future days without AI
    osha_heat_alert: oshaHeatAlert,
    osha_heat_details: oshaDetails,
    confidence: 0.7, // Lower confidence for rule-based decisions
    fallback: true,
    ai_unavailable: true
  }
}];