Chapter 03: Screening Protocols

// Example: Conversational PHQ-9 Implementation
import { ConversationalScreening } from '@wia/mental-002';

class ConversationalPHQ9 {
  constructor() {
    this.screener = new ConversationalScreening({
      instrument: 'PHQ-9',
      conversationStyle: 'empathetic',
      adaptiveBranching: true,
      culturalAdaptation: true
    });
  }

  async conductScreening(userId, conversationContext = {}) {
    const session = await this.screener.initializeSession({
      userId,
      previousConversations: conversationContext.history,
      demographicInfo: conversationContext.demographics
    });

    // Natural conversation flow integrating PHQ-9 items
    const responses = [];

    // Example: Instead of "Little interest or pleasure in doing things?"
    // AI adapts to conversation: "You mentioned you've been staying home more.
    // Have you noticed a change in how much you enjoy your usual activities?"

    for (const item of this.screener.getAdaptedItems()) {
      const response = await this.screener.askItem(item, {
        conversationContext: session.context,
        previousResponses: responses,
        adaptationStrategy: 'contextual'
      });

      responses.push({
        itemId: item.id,
        originalItem: item.standardText,
        adaptedQuestion: response.questionAsAsked,
        userResponse: response.answer,
        clarifications: response.clarifyingExchanges,
        confidence: response.scoringConfidence
      });

      // Update conversation context
      session.context = response.updatedContext;
    }

    // Calculate PHQ-9 score with confidence intervals
    const scoring = await this.screener.calculateScore(responses);

    return {
      instrumentScores: {
        phq9Total: scoring.totalScore,
        confidenceInterval: scoring.confidence,
        itemScores: scoring.itemBreakdown,
        suicidalIdeation: scoring.item9Score // Critical item
      },
      clinicalInterpretation: {
        severity: this.categorizeSeverity(scoring.totalScore),
        recommendations: this.generateRecommendations(scoring),
        requiresImmediateAction: scoring.item9Score >= 2,
        requiresFollowUp: scoring.totalScore >= 10
      },
      conversationalQuality: {
        naturalness: session.naturalness,
        userEngagement: session.engagement,
        completionQuality: scoring.completeness
      }
    };
  }

  categorizeSeverity(score) {
    if (score >= 20) return 'severe';
    if (score >= 15) return 'moderately-severe';
    if (score >= 10) return 'moderate';
    if (score >= 5) return 'mild';
    return 'minimal';
  }

  generateRecommendations(scoring) {
    const recommendations = [];

    if (scoring.item9Score >= 2) {
      recommendations.push({
        priority: 'immediate',
        action: 'suicide-risk-protocol',
        description: 'Activate crisis intervention protocol'
      });
    }

    if (scoring.totalScore >= 15) {
      recommendations.push({
        priority: 'urgent',
        action: 'clinical-referral',
        description: 'Refer for immediate clinical evaluation'
      });
    } else if (scoring.totalScore >= 10) {
      recommendations.push({
        priority: 'high',
        action: 'clinical-assessment',
        description: 'Schedule comprehensive clinical assessment'
      });
    } else if (scoring.totalScore >= 5) {
      recommendations.push({
        priority: 'moderate',
        action: 'monitoring',
        description: 'Continue monitoring, consider self-help resources'
      });
    }

    return recommendations;
  }
}

// Usage
const phq9Screener = new ConversationalPHQ9();
const screeningResult = await phq9Screener.conductScreening('user-789', {
  history: previousConversations,
  demographics: { age: 28, gender: 'female', culture: 'western' }
});

console.log(screeningResult.clinicalInterpretation);
// Output: { severity: 'moderate', recommendations: [...], requiresFollowUp: true }

// Example: Crisis Detection System with Safety Protocols
import { CrisisDetection } from '@wia/mental-002';

class CrisisDetectionSystem {
  constructor() {
    this.detector = new CrisisDetection({
      sensitivityLevel: 'high', // Err on side of caution
      multiFactorVerification: true,
      humanOversight: 'required',
      escalationProtocol: 'immediate'
    });

    this.crisisHotlines = {
      'US': '988',
      'UK': '116123',
      'global': '988' // Default to US
    };
  }

  async assessCrisisRisk(input) {
    // Multi-factor crisis assessment
    const assessments = await Promise.all([
      this.detector.analyzeSuicidalLanguage(input.text),
      this.detector.assessSeverityIndicators(input.screeningScores),
      this.detector.evaluateBehavioralWarnings(input.digitalPhenotype),
      this.detector.checkHistoricalPatterns(input.userId)
    ]);

    // Integrate multiple risk signals
    const riskScore = this.calculateIntegratedRisk(assessments);

    // Immediate action threshold
    if (riskScore.immediate >= 0.7) {
      return await this.activateCrisisProtocol({
        userId: input.userId,
        riskAssessment: riskScore,
        evidenceSummary: this.summarizeEvidence(assessments),
        timestamp: new Date()
      });
    }

    // Elevated risk monitoring
    if (riskScore.elevated >= 0.5) {
      return await this.escalateToHighRiskMonitoring({
        userId: input.userId,
        riskLevel: riskScore,
        monitoringPlan: this.createMonitoringPlan(riskScore)
      });
    }

    // Standard monitoring
    return {
      riskLevel: 'standard',
      score: riskScore,
      action: 'continue-monitoring',
      nextAssessment: this.calculateNextAssessment(riskScore)
    };
  }

  async activateCrisisProtocol(crisisData) {
    // Step 1: Immediate notification to crisis team
    await this.notifyCrisisTeam({
      priority: 'critical',
      userId: crisisData.userId,
      riskScore: crisisData.riskAssessment,
      evidence: crisisData.evidenceSummary
    });

    // Step 2: Connect user to immediate support
    const supportConnection = await this.connectToCrisisSupport(
      crisisData.userId
    );

    // Step 3: Activate safety planning if available
    const safetyPlan = await this.retrieveSafetyPlan(crisisData.userId);

    // Step 4: Notify emergency contacts if authorized
    if (await this.isEmergencyContactAuthorized(crisisData.userId)) {
      await this.notifyEmergencyContacts(crisisData);
    }

    // Step 5: Log all actions for clinical review
    await this.logCrisisEvent({
      ...crisisData,
      actionsT: [
        'crisis-team-notified',
        'support-connected',
        'safety-plan-activated',
        'emergency-contacts-notified'
      ],
      humanReviewRequired: true,
      humanReviewBy: new Date(Date.now() + 5 * 60000) // 5 minutes
    });

    return {
      status: 'crisis-protocol-activated',
      supportConnection,
      safetyPlan,
      nextSteps: [
        'Crisis counselor will contact within 5 minutes',
        'Emergency services on standby',
        'Continuous monitoring activated'
      ]
    };
  }

  calculateIntegratedRisk(assessments) {
    // Weight different risk factors
    const weights = {
      suicidalLanguage: 0.40,
      severityIndicators: 0.25,
      behavioralWarnings: 0.20,
      historicalPatterns: 0.15
    };

    let immediateRisk = 0;
    let elevatedRisk = 0;

    for (const [key, weight] of Object.entries(weights)) {
      const assessment = assessments.find(a => a.type === key);
      immediateRisk += assessment.immediateScore * weight;
      elevatedRisk += assessment.elevatedScore * weight;
    }

    return {
      immediate: immediateRisk,
      elevated: elevatedRisk,
      confidence: this.calculateConfidence(assessments),
      factorsPresent: assessments.filter(a => a.present).map(a => a.type)
    };
  }
}