You are an expert support triage analyst for a B2B SaaS company.
Analyze the support case below and classify its severity.
CASE SUBJECT: {!CaseSubject}
CASE DESCRIPTION: {!CaseDescription}
ACCOUNT NAME: {!AccountName}
ACCOUNT TIER: {!AccountTier}
SEVERITY DEFINITIONS:
P1 - System down, data loss, security incident, revenue impact,
     or affects multiple users / entire account
P2 - Major feature broken, workaround exists, limited scope
P3 - Minor issue, cosmetic bug, low-frequency path
P4 - Question, how-to, feature request, general feedback
HARD RULES:
- If description contains "data loss", "security", "breach",
  or "compliance" — severity must be P1, confidence must be 95+
- Account Tier = Enterprise amplifies severity if description
  is borderline between two levels
CONFIDENCE SCORING — READ CAREFULLY:
Score confidence LOWER when any of these are true:
- Description is vague, one sentence, or missing key details
- Subject and description suggest different severity levels
- Impact scope is unclear (one user? all users? unknown?)
- Customer uses emotional language without technical evidence
- Case could reasonably be classified as two different severities
Score confidence HIGHER only when ALL of these are true:
- Impact scope is clearly stated
- Technical symptoms are specific and unambiguous
- Severity bucket has no overlap with adjacent levels
Respond ONLY in this exact JSON format with no other text:
{
  "severity": "P1|P2|P3|P4",
  "confidence": <integer 0-100>,
  "rationale": "<one sentence explaining classification>",
  "ambiguity_reason": "<one sentence if confidence < 80, else null>"
}

// ============================================================
// ESCALATION TRIAGE AGENT SCRIPT
// HSAD Gates: Hard guardrail (keywords) + Pre-routing (confidence)
// ============================================================
// STEP 1: Fetch enriched case context
// Always first — downstream actions depend on this output
const caseContext = await actions.Get_Case_Context({
    caseId: context.recordId
});
// Null guard — failed data fetch should never silently route a case
if (!caseContext || !caseContext.caseDescription) {
    await actions.Update_Case_And_Route({
        caseId: context.recordId,
        triageStatus: "Flagged for Review",
        ambiguityReason: "Could not retrieve case details for classification",
        suggestedTier: "Human_Review_AI_Flagged"
    });
    return;
}
// STEP 2: Hard guardrail — check BEFORE calling the LLM
// Why before: Don't waste an Einstein API call on cases
// that must always go to human review regardless
const desc = caseContext.caseDescription.toLowerCase();
const subj = caseContext.caseSubject?.toLowerCase() || "";
const sensitiveKeywords = [
    "data loss", "security", "breach",
    "compliance", "gdpr", "hack", "exposed"
];
const hasSensitiveKeyword = sensitiveKeywords.some(k =>
    desc.includes(k) || subj.includes(k)
);
if (hasSensitiveKeyword) {
    await actions.Update_Case_And_Route({
        caseId: context.recordId,
        aiSeverity: "P1",
        aiConfidence: 99,
        rationale: "Sensitive keyword — mandatory human review",
        triageStatus: "Flagged for Review",
        ambiguityReason: "Hard guardrail triggered",
        suggestedTier: "Tier_3_Engineering_Escalation"
    });
    return; // Done. Human reviews this.
}
// STEP 3: LLM Classification via Prompt Template
const classificationResult = await actions.Classify_Case_Severity({
    CaseSubject: caseContext.caseSubject,
    CaseDescription: caseContext.caseDescription,
    AccountName: caseContext.accountName,
    AccountTier: caseContext.accountTier
});
// Parse JSON output — if parse fails, flag immediately
// Never route on malformed classification data
let classification;
try {
    classification = JSON.parse(classificationResult.result);
} catch (e) {
    await actions.Update_Case_And_Route({
        caseId: context.recordId,
        triageStatus: "Flagged for Review",
        ambiguityReason: "Prompt template returned malformed output"
    });
    return;
}
const { severity, confidence, rationale, ambiguity_reason } = classification;
// STEP 4: Autonomy Decision Matrix
// Principle: (impact of wrong decision) × (confidence) = autonomy level
let triageStatus, suggestedTier;
if (severity === "P1" && confidence >= 85) {
    triageStatus = "Auto-Routed";
    suggestedTier = "Tier_3_Engineering_Escalation";
} else if (severity === "P1" && confidence < 85) {
    // Never auto-route P1 with doubt — SLA breach risk too high
    triageStatus = "Flagged for Review";
    suggestedTier = "Tier_3_Engineering_Escalation";
} else if (severity === "P2" && confidence >= 75) {
    triageStatus = "Auto-Routed";
    suggestedTier = "Tier_2_Technical_Support";
} else if (severity === "P2" && confidence < 75) {
    triageStatus = "Flagged for Review";
    suggestedTier = "Tier_2_Technical_Support";
} else if (severity === "P3" && confidence >= 75) {
    triageStatus = "Auto-Routed";
    suggestedTier = "Tier_1_General_Support";
} else if (severity === "P4") {
    // P4 = always auto-route — low stakes, high volume
    triageStatus = "Auto-Routed";
    suggestedTier = "Tier_1_General_Support";
} else {
    // Catch-all: when in doubt, always defer to human
    triageStatus = "Flagged for Review";
    suggestedTier = "Human_Review_AI_Flagged";
}
// STEP 5: Write decision back to record — every case, always
// Audit trail is non-negotiable in a supervised system
await actions.Update_Case_And_Route({
    caseId: context.recordId,
    aiSeverity: severity,
    aiConfidence: confidence,
    rationale: rationale,
    triageStatus: triageStatus,
    ambiguityReason: ambiguity_reason || null,
    suggestedTier: suggestedTier
});