Chapter 2: Assessment & Treatment Planning Systems

Introduction

Effective addiction treatment begins with comprehensive assessment. Just as a physician wouldn't prescribe medication without first diagnosing the condition, addiction treatment requires thorough evaluation to understand the nature, severity, and context of the disorder before developing an appropriate treatment plan.

Digital assessment systems offer significant advantages over traditional paper-and-pencil methods: automated scoring, reduced administration time, adaptive questioning that tailors follow-up items based on responses, integration with electronic health records, longitudinal tracking of symptom changes, and the ability to administer assessments in the patient's natural environment rather than only in clinical settings.

This chapter explores the key components of digital addiction assessment and treatment planning, including screening tools, diagnostic instruments, severity measures, risk assessments, and computerized treatment planning systems that translate assessment data into personalized, evidence-based treatment recommendations.

Screening Instruments

Screening tools are brief questionnaires designed to identify individuals who may have a substance use disorder or behavioral addiction and require more comprehensive evaluation. They prioritize sensitivity (catching all possible cases) over specificity (ruling out non-cases).

Common Screening Tools

Tool	Target	Items	Scoring	Digital Implementation
AUDIT (Alcohol Use Disorders Identification Test)	Alcohol	10 items	0-40, ≥8 indicates hazardous drinking	Web/app form, auto-scoring, risk stratification
DAST-10 (Drug Abuse Screening Test)	Drugs	10 items	0-10, ≥3 suggests probable disorder	Checkbox interface, instant results
CAGE (Cut-Annoyed-Guilty-Eye)	Alcohol	4 items	0-4, ≥2 suggests problem drinking	Quick mobile assessment (<1 min)
NIDA Quick Screen	Multiple substances	1 primary + follow-ups	Frequency-based assessment	Adaptive branching logic
CRAFFT	Adolescent substance use	6 items	0-6, ≥2 indicates high risk	Age-gated version, parent notification options
CUDIT-R (Cannabis Use Disorder ID Test)	Cannabis	8 items	0-32, ≥8 suggests disorder	Cannabis-specific symptom tracking
IGDS9-SF (Internet Gaming Disorder Scale)	Gaming	9 items	DSM-5 criteria mapping	In-game integration possible
PGSI (Problem Gambling Severity Index)	Gambling	9 items	0-27, risk categories	Gambling platform integration

Digital Screening Implementation

                
// Screening Tool Implementation Example

interface ScreeningTool {
  id: string;
  name: string;
  target: string; // Substance or behavior
  items: ScreeningItem[];
  scoringRules: ScoringRule[];
  cutoffScores: CutoffScore[];
}

interface ScreeningItem {
  id: string;
  question: string;
  responseType: 'likert' | 'yes-no' | 'frequency' | 'numeric';
  options?: ResponseOption[];
  conditionalDisplay?: ConditionalLogic; // Adaptive questioning
}

class ScreeningSystem {
  async administerScreening(toolId: string, userId: string): Promise<ScreeningResult> {
    const tool = await this.loadScreeningTool(toolId);
    const responses = await this.collectResponses(tool, userId);
    const score = this.calculateScore(tool, responses);
    const interpretation = this.interpretScore(tool, score);
    const recommendations = this.generateRecommendations(interpretation);

    // Store results
    await this.database.screeningResults.insert({
      userId,
      toolId,
      timestamp: new Date(),
      responses,
      score,
      interpretation,
      recommendations,
    });

    return {
      score,
      interpretation,
      riskLevel: this.categorizeRisk(tool, score),
      recommendations,
      nextSteps: this.determineNextSteps(interpretation),
    };
  }

  private calculateScore(tool: ScreeningTool, responses: Response[]): number {
    let totalScore = 0;
    
    for (const rule of tool.scoringRules) {
      const response = responses.find(r => r.itemId === rule.itemId);
      if (response) {
        totalScore += rule.scoreMapping[response.value] || 0;
      }
    }

    return totalScore;
  }

  private interpretScore(tool: ScreeningTool, score: number): string {
    for (const cutoff of tool.cutoffScores) {
      if (score >= cutoff.minimumScore) {
        return cutoff.interpretation;
      }
    }
    return 'Low risk';
  }

  private generateRecommendations(interpretation: string): Recommendation[] {
    const recommendationMap = {
      'High risk - probable disorder': [
        { action: 'Comprehensive diagnostic assessment', priority: 'urgent' },
        { action: 'Referral to addiction specialist', priority: 'urgent' },
        { action: 'Safety planning if needed', priority: 'urgent' },
      ],
      'Moderate risk - hazardous use': [
        { action: 'Brief intervention', priority: 'high' },
        { action: 'Monitoring and reassessment in 30 days', priority: 'medium' },
        { action: 'Psychoeducation about risks', priority: 'medium' },
      ],
      'Low risk': [
        { action: 'Positive feedback on healthy behaviors', priority: 'low' },
        { action: 'Prevention education', priority: 'low' },
      ],
    };

    return recommendationMap[interpretation] || [];
  }
}

// Adaptive Screening with Branching Logic
class AdaptiveScreening {
  async administeredAdaptiveAUDIT(userId: string): Promise<ScreeningResult> {
    const responses = [];

    // Question 1: How often do you have a drink containing alcohol?
    const q1 = await this.askQuestion({
      question: 'How often do you have a drink containing alcohol?',
      options: ['Never', 'Monthly or less', '2-4 times/month', '2-3 times/week', '4+ times/week'],
    });
    responses.push(q1);

    // If never drinks, skip remaining questions
    if (q1.value === 'Never') {
      return this.generateResult(responses, 0);
    }

    // Question 2-3: Quantity and binge drinking
    const q2 = await this.askQuestion({
      question: 'How many standard drinks do you have on a typical drinking day?',
      options: ['1-2', '3-4', '5-6', '7-9', '10+'],
    });
    responses.push(q2);

    const q3 = await this.askQuestion({
      question: 'How often do you have 6+ drinks on one occasion?',
      options: ['Never', 'Less than monthly', 'Monthly', 'Weekly', 'Daily or almost daily'],
    });
    responses.push(q3);

    // If low scores so far, can skip some dependency questions
    const currentScore = this.calculatePartialScore(responses);
    if (currentScore < 4) {
      // Ask only critical questions 4, 6, 9
      // Skip redundant items for low-risk individuals
    } else {
      // Ask all remaining questions for potential high-risk individuals
    }

    // Continue adaptive questioning...
    // ... remaining questions with conditional logic

    const finalScore = this.calculateScore(responses);
    return this.generateResult(responses, finalScore);
  }
}
                
            

Diagnostic Assessment

Following positive screening results, comprehensive diagnostic assessment determines whether an individual meets criteria for a substance use disorder or behavioral addiction according to standard diagnostic systems (DSM-5 or ICD-11).

DSM-5 Substance Use Disorder Criteria

The DSM-5 defines substance use disorder based on 11 criteria across four categories, with severity determined by the number of criteria met:

Category	Criteria	Assessment Questions
Impaired Control	1. Using more/longer than intended 2. Unsuccessful efforts to cut down 3. Much time spent obtaining/using/recovering 4. Craving or strong urge to use	"Do you often end up using more than you planned?" "Have you tried to cut down or quit but been unable to?" "Does use take up a lot of your time?" "Do you experience strong cravings?"
Social Impairment	5. Failure to fulfill major role obligations 6. Continued use despite social/interpersonal problems 7. Important activities given up or reduced	"Has use interfered with work, school, or home responsibilities?" "Do you continue using despite relationship problems?" "Have you given up important activities because of use?"
Risky Use	8. Use in physically hazardous situations 9. Continued use despite physical/psychological problems	"Do you use in dangerous situations (driving, operating machinery)?" "Do you continue despite health problems caused/worsened by use?"
Pharmacological	10. Tolerance (need more for effect) 11. Withdrawal (symptoms when stopping)	"Do you need more to get the same effect as before?" "Do you experience withdrawal symptoms when you stop or reduce use?"

Severity Classification:

Mild: 2-3 criteria met
Moderate: 4-5 criteria met
Severe: 6+ criteria met

Computerized Diagnostic Interviews

                
// DSM-5 Substance Use Disorder Diagnostic Assessment

class DiagnosticAssessment {
  async assessSUD(userId: string, substance: string): Promise<DiagnosticResult> {
    const criteria = await this.assessAllCriteria(userId, substance);
    const criteriaCount = criteria.filter(c => c.met).length;
    const severity = this.determineSeverity(criteriaCount);
    const diagnosis = this.generateDiagnosis(substance, severity, criteriaCount);

    // Assess additional factors
    const cooccurringDisorders = await this.screenCooccurring(userId);
    const psychosocialFactors = await this.assessPsychosocial(userId);
    const readinessToChange = await this.assessMotivation(userId);

    // Generate comprehensive diagnostic report
    return {
      diagnosis,
      severity,
      criteriaMet: criteriaCount,
      criteriaDetails: criteria,
      cooccurringDisorders,
      psychosocialFactors,
      readinessToChange,
      treatmentRecommendations: await this.generateTreatmentPlan({
        diagnosis,
        severity,
        cooccurringDisorders,
        psychosocialFactors,
        readinessToChange,
      }),
    };
  }

  private async assessAllCriteria(userId: string, substance: string): Promise<CriterionResult[]> {
    const criteria = this.getDSM5Criteria(substance);
    const results = [];

    for (const criterion of criteria) {
      const questions = this.getCriterionQuestions(criterion);
      const responses = await this.askQuestions(questions, userId);
      const met = this.evaluateCriterion(criterion, responses);
      
      results.push({
        criterion: criterion.name,
        category: criterion.category,
        met: met,
        responses: responses,
        confidence: this.calculateConfidence(responses),
      });
    }

    return results;
  }

  private determineSeverity(criteriaCount: number): 'None' | 'Mild' | 'Moderate' | 'Severe' {
    if (criteriaCount < 2) return 'None';
    if (criteriaCount <= 3) return 'Mild';
    if (criteriaCount <= 5) return 'Moderate';
    return 'Severe';
  }

  private async screenCooccurring(userId: string): Promise<CooccurringDisorder[]> {
    // Screen for common co-occurring conditions
    const screeningTools = [
      { tool: 'PHQ-9', condition: 'Depression' },
      { tool: 'GAD-7', condition: 'Anxiety' },
      { tool: 'PCL-5', condition: 'PTSD' },
      { tool: 'MDQ', condition: 'Bipolar Disorder' },
      { tool: 'ADHD-RS', condition: 'ADHD' },
    ];

    const results = [];
    for (const screen of screeningTools) {
      const score = await this.administerScreener(screen.tool, userId);
      if (score.positive) {
        results.push({
          condition: screen.condition,
          screeningScore: score.value,
          recommendsEvaluation: true,
        });
      }
    }

    return results;
  }
}

// Structured Clinical Interview
class StructuredInterview {
  async conductClinicalInterview(userId: string): Promise<InterviewResult> {
    const sections = {
      substanceUseHistory: await this.assessSubstanceHistory(userId),
      treatmentHistory: await this.assessTreatmentHistory(userId),
      medicalHistory: await this.assessMedicalHistory(userId),
      psychiatricHistory: await this.assessPsychiatricHistory(userId),
      familyHistory: await this.assessFamilyHistory(userId),
      socialHistory: await this.assessSocialHistory(userId),
      legalHistory: await this.assessLegalHistory(userId),
      traumaHistory: await this.assessTraumaHistory(userId),
    };

    return this.compileInterviewResults(sections);
  }

  private async assessSubstanceHistory(userId: string): Promise<SubstanceHistory> {
    return {
      substancesUsed: await this.getSubstancesUsed(userId),
      ageOfFirstUse: await this.getAgeOfFirstUse(userId),
      patternOfUse: await this.getPatternOfUse(userId),
      routeOfAdministration: await this.getRouteOfAdministration(userId),
      quantityAndFrequency: await this.getQuantityFrequency(userId),
      lastUseDate: await this.getLastUseDate(userId),
      longestAbstinencePeriod: await this.getLongestAbstinence(userId),
      consequencesExperienced: await this.getConsequences(userId),
    };
  }
}
                
            

Severity and Functional Assessment

Beyond diagnosis, understanding the severity of addiction and its impact on functioning is critical for treatment planning. Several standardized instruments measure these dimensions:

Severity Measurement Tools

Instrument	Domains Assessed	Administration	Use in Treatment Planning
ASI (Addiction Severity Index)	Medical, employment, alcohol, drugs, legal, family/social, psychiatric	60-90 min interview	Comprehensive baseline, monitors change over time, prioritizes treatment domains
TLFB (Timeline Follow-back)	Daily substance use patterns over 30-90 days	15-30 min calendar method	Identifies high-risk periods, triggers, patterns for intervention targeting
COWS/CIWA (Withdrawal Scales)	Opioid/alcohol withdrawal severity	5-10 min observation + vital signs	Guides medication dosing for medical detox
SDS (Severity of Dependence Scale)	Psychological dependence	5 items, <5 min	Quick severity assessment for specific substance
InDUC (Inventory of Drug Use Consequences)	Adverse consequences across life domains	50 items, 10-15 min	Identifies specific problems requiring intervention

Digital Timeline Follow-back Implementation

                
// Timeline Follow-back (TLFB) Digital Implementation

class TimelineFollowback {
  async conductTLFB(userId: string, days: number = 30): Promise<TLFBResult> {
    const calendar = await this.generateCalendar(days);
    const memoryAids = await this.getMemoryAids(userId, days);
    
    // Interactive calendar interface
    const dailyData = [];
    for (let day of calendar) {
      const dayData = await this.assessDay(userId, day, memoryAids);
      dailyData.push(dayData);
    }

    // Analyze patterns
    const patterns = this.analyzePatterns(dailyData);
    
    return {
      dailyData,
      summary: {
        totalDaysUsed: dailyData.filter(d => d.used).length,
        totalDaysAbstinent: dailyData.filter(d => !d.used).length,
        averageQuantity: this.calculateAverageQuantity(dailyData),
        bingeDays: dailyData.filter(d => d.binge).length,
        heavyUseDays: dailyData.filter(d => d.heavyUse).length,
      },
      patterns: {
        dayOfWeekPattern: this.analyzeDayOfWeek(dailyData),
        triggerPattern: this.analyzeTriggers(dailyData),
        quantityTrends: this.analyzeQuantityTrends(dailyData),
        abstinenceStreaks: this.identifyAbstinenceStreaks(dailyData),
      },
      visualizations: await this.generateVisualizations(dailyData, patterns),
    };
  }

  private async assessDay(userId: string, date: Date, memoryAids: MemoryAid[]): Promise<DayData> {
    // Show relevant memory aids (holidays, events, photos from that day)
    const relevantAids = memoryAids.filter(aid => this.isRelevant(aid, date));
    
    return {
      date,
      used: await this.askYesNo(`Did you use on ${this.formatDate(date)}?`, relevantAids),
      substances: await this.askSubstances('Which substances?'),
      quantity: await this.askQuantity('How much?'),
      context: await this.askContext('Where and with whom?'),
      triggers: await this.askTriggers('What led to use?'),
      consequences: await this.askConsequences('What happened afterward?'),
    };
  }

  private analyzePatterns(dailyData: DayData[]): PatternAnalysis {
    return {
      weekdayVsWeekend: {
        weekdayUseRate: this.calculateUseRate(dailyData, 'weekday'),
        weekendUseRate: this.calculateUseRate(dailyData, 'weekend'),
        significance: this.testSignificance('weekday', 'weekend', dailyData),
      },
      timeBasedTrends: {
        increasingUse: this.detectTrend(dailyData, 'increasing'),
        decreasingUse: this.detectTrend(dailyData, 'decreasing'),
        cyclicPatterns: this.detectCyclicPatterns(dailyData),
      },
      triggerIdentification: {
        mostCommonTriggers: this.rankTriggers(dailyData),
        triggerUseAssociation: this.calculateTriggerAssociations(dailyData),
      },
    };
  }
}
                
            

Risk Assessment

Comprehensive addiction assessment must evaluate multiple types of risk to ensure patient safety and guide appropriate level of care:

Risk Domains

Overdose Risk: Particularly for opioids, polysubstance use, return to use after abstinence period
Withdrawal Risk: Medical complications from alcohol or benzodiazepine withdrawal (seizures, delirium tremens)
Suicide Risk: Elevated during intoxication, withdrawal, and early recovery; assess ideation, plan, means, intent
Violence Risk: Toward self or others, especially with stimulant use, alcohol, and co-occurring disorders
Relapse Risk: Likelihood of return to use based on severity, triggers, support system, coping skills
Medical Risk: Infectious diseases (HIV, hepatitis), cardiovascular issues, liver disease, malnutrition
Psychosocial Risk: Housing instability, unemployment, legal problems, child custody issues

Risk Stratification System

                
// Comprehensive Risk Assessment System

class RiskAssessmentSystem {
  async assessAllRisks(userId: string): Promise<RiskProfile> {
    const risks = {
      overdose: await this.assessOverdoseRisk(userId),
      withdrawal: await this.assessWithdrawalRisk(userId),
      suicide: await this.assessSuicideRisk(userId),
      violence: await this.assessViolenceRisk(userId),
      relapse: await this.assessRelapseRisk(userId),
      medical: await this.assessMedicalRisk(userId),
      psychosocial: await this.assessPsychosocialRisk(userId),
    };

    const overallRisk = this.calculateOverallRisk(risks);
    const interventions = this.recommendInterventions(risks, overallRisk);
    const levelOfCare = this.recommendLevelOfCare(risks, overallRisk);

    return {
      risks,
      overallRisk,
      interventions,
      levelOfCare,
      monitoring: this.createMonitoringPlan(risks),
    };
  }

  private async assessOverdoseRisk(userId: string): Promise<RiskLevel> {
    const factors = {
      opioidUse: await this.checkOpioidUse(userId),
      polysubstanceUse: await this.checkPolysubstance(userId),
      highDosage: await this.checkDosage(userId),
      recentAbstinence: await this.checkRecentAbstinence(userId), // Reduced tolerance
      aloneUse: await this.checkUsageContext(userId),
      fentanylRisk: await this.checkFentanylContamination(userId),
      priorOverdose: await this.checkOverdoseHistory(userId),
      naloxoneAccess: await this.checkNaloxoneAccess(userId),
    };

    const riskScore = this.calculateRiskScore(factors, this.overdoseWeights);
    
    return {
      level: this.categorizeRisk(riskScore),
      score: riskScore,
      factors: factors,
      interventions: this.getOverdoseInterventions(riskScore, factors),
    };
  }

  private async assessSuicideRisk(userId: string): Promise<RiskLevel> {
    // Columbia Suicide Severity Rating Scale (C-SSRS)
    const assessment = {
      ideation: await this.assessSuicidalIdeation(userId),
      plan: await this.assessSuicidalPlan(userId),
      intent: await this.assessSuicidalIntent(userId),
      behaviors: await this.assessSuicidalBehaviors(userId),
      priorAttempts: await this.checkPriorAttempts(userId),
      accessToMeans: await this.checkAccessToMeans(userId),
      protectiveFactors: await this.assessProtectiveFactors(userId),
    };

    const imminent = this.determineImminentRisk(assessment);
    
    if (imminent) {
      await this.triggerCrisisProtocol(userId);
    }

    return {
      level: this.categorizeSuicideRisk(assessment),
      imminent: imminent,
      assessment: assessment,
      interventions: this.getSuicideInterventions(assessment),
      safetyPlan: await this.createSafetyPlan(userId, assessment),
    };
  }

  private recommendLevelOfCare(risks: RiskProfile, overall: RiskLevel): LevelOfCare {
    // ASAM Criteria-based placement
    if (overall.level === 'Severe' || risks.suicide.imminent || risks.withdrawal.level === 'Severe') {
      return 'Inpatient Medical Detox / Psychiatric Hospitalization';
    } else if (overall.level === 'High' || risks.relapse.level === 'High') {
      return 'Residential Treatment / Partial Hospitalization';
    } else if (overall.level === 'Moderate') {
      return 'Intensive Outpatient Program';
    } else {
      return 'Outpatient Treatment';
    }
  }
}
                
            

Personalized Treatment Planning

Assessment data must translate into actionable, personalized treatment plans that address the individual's unique needs, preferences, and circumstances. Modern treatment planning systems integrate assessment results with evidence-based treatment algorithms to generate comprehensive, individualized care plans.

Treatment Plan Components

Component	Description	Digital Implementation
Problem List	Identified issues from assessment (e.g., severe alcohol use disorder, depression, unemployment)	Auto-populated from diagnostic and severity assessments
Treatment Goals	SMART goals collaboratively developed with patient (Specific, Measurable, Achievable, Relevant, Time-bound)	Goal library with customization, progress tracking dashboard
Interventions	Evidence-based treatments matched to problems (e.g., CBT for alcohol use, SSRI for depression)	Algorithm-driven intervention matching, clinical decision support
Medications	FDA-approved addiction medications and psychiatric medications	Electronic prescribing, medication adherence tracking, side effect monitoring
Frequency/Duration	How often interventions occur and expected treatment duration	Automated scheduling, calendar integration, reminder systems
Progress Measures	Metrics to evaluate treatment effectiveness	Automated outcome tracking, real-time dashboards, alerts for lack of progress
Discharge Criteria	Conditions for successful completion or transition to lower level of care	Milestone tracking, automated transitions, continuing care planning

Treatment Planning Algorithm

                
// Personalized Treatment Planning System

class TreatmentPlanner {
  async generateTreatmentPlan(assessmentData: AssessmentData): Promise<TreatmentPlan> {
    // Extract key information
    const diagnosis = assessmentData.diagnosis;
    const severity = assessmentData.severity;
    const risks = assessmentData.risks;
    const cooccurring = assessmentData.cooccurringDisorders;
    const preferences = assessmentData.patientPreferences;
    const barriers = assessmentData.barriers;

    // Generate problem list
    const problems = this.identifyProblems(assessmentData);

    // Develop goals collaboratively
    const goals = await this.developGoals(problems, preferences);

    // Match interventions to problems
    const interventions = this.matchInterventions(problems, severity, preferences);

    // Determine medications
    const medications = this.recommendMedications(diagnosis, severity, cooccurring);

    // Assign frequency and duration
    const schedule = this.createSchedule(severity, risks, barriers);

    // Define progress measures
    const measures = this.defineProgressMeasures(goals, interventions);

    // Set discharge criteria
    const dischargeCriteria = this.setDischargeCriteria(severity, goals);

    return {
      problems,
      goals,
      interventions,
      medications,
      schedule,
      measures,
      dischargeCriteria,
      reviewDate: this.calculateReviewDate(severity),
    };
  }

  private matchInterventions(
    problems: Problem[],
    severity: Severity,
    preferences: PatientPreferences
  ): Intervention[] {
    const interventions = [];

    for (const problem of problems) {
      // Get evidence-based interventions for this problem
      const candidates = this.getEvidenceBasedInterventions(problem);

      // Filter by patient preferences and contraindications
      const suitable = candidates.filter(intervention => 
        this.isSuitable(intervention, preferences) &&
        !this.hasContraindications(intervention, problem)
      );

      // Rank by effectiveness for this patient profile
      const ranked = this.rankByEffectiveness(suitable, problem, severity);

      // Select top intervention(s)
      interventions.push(...ranked.slice(0, 2)); // Top 2 interventions per problem
    }

    return this.deduplicateAndPrioritize(interventions);
  }

  private recommendMedications(
    diagnosis: Diagnosis,
    severity: Severity,
    cooccurring: CooccurringDisorder[]
  ): Medication[] {
    const medications = [];

    // Medication-Assisted Treatment (MAT) for substance use disorders
    if (diagnosis.substance === 'Opioids') {
      if (severity === 'Moderate' || severity === 'Severe') {
        medications.push({
          name: 'Buprenorphine-Naloxone',
          dosage: '8-16mg daily',
          rationale: 'First-line MAT for opioid use disorder, reduces cravings and withdrawal',
          alternatives: ['Methadone', 'Naltrexone XR'],
        });
      }
    } else if (diagnosis.substance === 'Alcohol') {
      medications.push({
        name: 'Naltrexone',
        dosage: '50mg daily or 380mg IM monthly',
        rationale: 'Reduces alcohol cravings and blocks rewarding effects',
        alternatives: ['Acamprosate', 'Disulfiram'],
      });
    }

    // Medications for co-occurring disorders
    for (const disorder of cooccurring) {
      const psychMeds = this.getPsychiatricMedications(disorder);
      medications.push(...psychMeds);
    }

    return medications;
  }

  private async developGoals(
    problems: Problem[],
    preferences: PatientPreferences
  ): Promise<Goal[]> {
    const goals = [];

    for (const problem of problems) {
      // Generate default goal
      const defaultGoal = this.generateDefaultGoal(problem);

      // Customize with patient input
      const customizedGoal = await this.customizeWithPatient(defaultGoal, preferences);

      // Ensure SMART criteria
      const smartGoal = this.ensureSMART(customizedGoal);

      goals.push(smartGoal);
    }

    return goals;
  }

  private ensureSMART(goal: Goal): Goal {
    return {
      ...goal,
      specific: this.ensureSpecific(goal.description),
      measurable: this.ensureMeasurable(goal.metric),
      achievable: this.ensureAchievable(goal.target),
      relevant: this.ensureRelevant(goal.problem),
      timeBound: this.ensureTimeBound(goal.deadline),
    };
  }
}

// Example treatment plan output
const examplePlan = {
  patient: 'User_12345',
  planDate: '2025-01-15',
  problems: [
    {
      id: 1,
      description: 'Severe Alcohol Use Disorder',
      priority: 'High',
    },
    {
      id: 2,
      description: 'Major Depressive Disorder',
      priority: 'High',
    },
    {
      id: 3,
      description: 'Unemployment',
      priority: 'Medium',
    },
  ],
  goals: [
    {
      problemId: 1,
      description: 'Achieve and maintain abstinence from alcohol',
      specific: 'Complete abstinence from all alcoholic beverages',
      measurable: 'Daily sobriety tracking via app, weekly UDS',
      achievable: 'With MAT, counseling, and peer support',
      relevant: 'Addresses primary diagnosis and reduces health risks',
      timeBound: '90 days to establish initial abstinence',
    },
    {
      problemId: 2,
      description: 'Reduce depressive symptoms',
      specific: 'PHQ-9 score below 10 (minimal depression)',
      measurable: 'Weekly PHQ-9 assessments',
      achievable: 'With antidepressant medication and CBT',
      relevant: 'Depression contributes to drinking and suicidal ideation',
      timeBound: '8-12 weeks for medication response',
    },
  ],
  interventions: [
    {
      problemId: 1,
      intervention: 'Cognitive Behavioral Therapy for Substance Use',
      frequency: 'Weekly individual sessions',
      duration: '12-16 weeks',
      provider: 'Licensed addiction counselor',
      deliveryMode: 'Video telehealth',
    },
    {
      problemId: 1,
      intervention: 'Group Therapy',
      frequency: '3x per week',
      duration: 'Ongoing',
      provider: 'Group facilitator',
      deliveryMode: 'In-person or virtual',
    },
    {
      problemId: 2,
      intervention: 'CBT for Depression',
      frequency: 'Weekly',
      duration: '16-20 weeks',
      provider: 'Clinical psychologist',
      deliveryMode: 'Video telehealth',
    },
  ],
  medications: [
    {
      problemId: 1,
      medication: 'Naltrexone',
      dosage: '50mg PO daily',
      rationale: 'Reduces alcohol cravings and rewarding effects',
      monitoring: 'Liver function tests at baseline and 3 months',
    },
    {
      problemId: 2,
      medication: 'Sertraline',
      dosage: '50mg PO daily, may increase to 200mg',
      rationale: 'SSRI for major depression',
      monitoring: 'PHQ-9 weekly, side effects, suicidality',
    },
  ],
};
                
            

Key Takeaways

Comprehensive assessment is the foundation of effective addiction treatment, requiring screening, diagnosis, severity measurement, and risk evaluation before treatment planning
Digital screening tools enable rapid, automated administration and scoring of validated instruments like AUDIT, DAST, and disorder-specific scales
DSM-5 diagnostic assessment evaluates 11 criteria across four categories (impaired control, social impairment, risky use, pharmacological), with severity based on criteria count (2-3 mild, 4-5 moderate, 6+ severe)
Timeline Follow-back (TLFB) provides detailed pattern analysis of substance use over 30-90 days, identifying triggers, high-risk periods, and trends essential for intervention targeting
Risk assessment must evaluate multiple domains: overdose, withdrawal, suicide, violence, relapse, medical, and psychosocial risks to ensure patient safety and appropriate level of care
Personalized treatment planning integrates assessment data with evidence-based algorithms to generate SMART goals, matched interventions, medication recommendations, and progress measures
Medication-Assisted Treatment (MAT) should be considered for moderate-severe opioid and alcohol use disorders, with buprenorphine, methadone, naltrexone as first-line options
Digital treatment planning systems provide clinical decision support, ensuring evidence-based care while allowing customization based on patient preferences and individual circumstances

Review Questions

What is the difference between screening and diagnostic assessment? When would you use each type of tool in the clinical workflow?
Explain the DSM-5 severity specifiers for substance use disorder. How many criteria must be met for mild, moderate, and severe classifications?
Describe how adaptive/branching logic in digital screening tools can improve efficiency and user experience. Provide an example.
What is Timeline Follow-back (TLFB), and what types of patterns can be identified from TLFB data? How would you use this information in treatment planning?
Why is suicide risk assessment critical in addiction treatment populations? Describe the key elements of suicide risk assessment using the C-SSRS framework.
What factors would you consider when determining appropriate level of care (outpatient vs. intensive outpatient vs. residential vs. inpatient) for someone with alcohol use disorder?
Explain the SMART criteria for treatment goals. Provide an example of a poorly written goal and how you would revise it to meet SMART criteria.
What are the first-line medication options for (a) opioid use disorder and (b) alcohol use disorder? What is the mechanism of action and expected benefits of each?
How can digital systems support clinical decision-making in treatment planning while still allowing for individualization based on patient preferences and circumstances?
Design a comprehensive assessment battery for a new patient presenting for addiction treatment. What tools would you include, in what order, and why?

弘益人間 · Benefit All Humanity

Comprehensive, compassionate assessment honors the complexity of each person's journey with addiction. By taking the time to truly understand the individual—their struggles, strengths, circumstances, and aspirations—we can develop treatment plans that address their unique needs rather than applying one-size-fits-all solutions.

Digital assessment systems democratize access to evidence-based evaluation tools that were previously available only in well-resourced specialty clinics. When implemented with care and clinical expertise, these technologies ensure that every person, regardless of where they live or their ability to pay, receives the same high-quality, comprehensive assessment that guides them toward effective, personalized treatment and lasting recovery.

Assessment & Treatment Planning Systems