@clawtrial/courtroom 1.0.3 → 2.0.0

package/src/hearing.js

@@ -1,16 +1,16 @@
 /**
- * Hearing Pipeline
+ * Hearing Pipeline - LLM-Based Deliberation
  * 
- * Orchestrates the full hearing process:
- * 1. Evidence compilation
- * 2. Judge LLM invocation
- * 3. Jury LLM invocations (3 jurors)
- * 4. Vote aggregation
- * 5. Verdict finalization
+ * Conducts a full hearing using the agent's LLM:
+ * 1. Judge evaluates the evidence
+ * 2. Jury deliberates (3 jurors with distinct perspectives)
+ * 3. Votes are tallied
+ * 4. Verdict + sentence returned
  */
 
 const { JUDGE_SYSTEM_PROMPT, JUDGE_EVIDENCE_TEMPLATE } = require('./prompts/judge');
 const { JUROR_ROLES, JURY_EVIDENCE_TEMPLATE } = require('./prompts/jury');
+const { logger } = require('./debug');
 
 class HearingPipeline {
   constructor(agentRuntime, configManager) {
@@ -19,440 +19,259 @@ class HearingPipeline {
   }
 
   /**
-   * Main hearing entry point
+   * Conduct a full hearing using the agent's LLM
+   * Returns a verdict object with { guilty, caseId, verdict, offense, proceedings, timestamp }
    */
   async conductHearing(caseData) {
-    const startTime = Date.now();
-    
-    // Step 1: Compile evidence
-    const compiledEvidence = this.compileEvidence(caseData);
-    
-    // Step 2: Invoke judge
-    const judgeOpinion = await this.invokeJudge(caseData, compiledEvidence);
-    
-    // Step 3: Invoke jury (3 jurors in parallel)
-    const juryVotes = await this.invokeJury(caseData, compiledEvidence);
-    
-    // Step 4: Aggregate votes
-    const voteTally = this.aggregateVotes(judgeOpinion, juryVotes);
-    
-    // Step 5: Finalize verdict
-    const verdict = this.finalizeVerdict(caseData, judgeOpinion, juryVotes, voteTally);
-    
-    const duration = Date.now() - startTime;
-    
-    return {
-      ...verdict,
-      metadata: {
-        duration,
-        judgeModel: judgeOpinion.model,
-        juryModels: juryVotes.map(v => v.model),
-        timestamp: new Date().toISOString()
-      }
+    const caseId = caseData.caseId || caseData.offense?.caseId || `case-${Date.now()}`;
+
+    logger.info('HEARING', 'Conducting hearing', { caseId });
+
+    // Normalize offense data from different input shapes
+    const offense = caseData.offense || caseData;
+    const offenseName = offense.offenseName || offense.name || 'Unknown Offense';
+    const severity = offense.severity || 'minor';
+    const confidence = offense.confidence || 0.5;
+    const evidence = offense.evidence || caseData.evidence || 'No evidence provided';
+    const humorTriggers = caseData.humorContext || caseData.humorTriggers || [];
+
+    const hearingData = {
+      caseId,
+      offenseName,
+      severity,
+      confidence,
+      evidence,
+      humorTriggers,
+      agentId: this.agent?.id || 'unknown'
     };
-  }
 
-  /**
-   * Compile and structure evidence for presentation
-   */
-  compileEvidence(caseData) {
-    return {
-      caseId: caseData.caseId,
-      offenseId: caseData.offenseId,
-      offenseName: caseData.offenseName,
-      severity: caseData.severity,
-      confidence: caseData.confidence,
-      evidence: caseData.evidence,
-      humorTriggers: caseData.humorTriggers || [],
-      sessionContext: {
-        turnsAnalyzed: caseData.evidence.sessionTurns,
-        evaluationWindow: this.config.get('detection.evaluationWindow')
+    const proceedings = [];
+
+    try {
+      // Step 1: Judge evaluation
+      const judgeVerdict = await this.getJudgeVerdict(hearingData);
+      proceedings.push({ speaker: 'Judge', message: judgeVerdict.commentary });
+
+      // Step 2: Jury deliberation
+      const juryVerdicts = await this.getJuryVerdicts(hearingData);
+      for (const juror of juryVerdicts) {
+        proceedings.push({ speaker: `Jury (${juror.role})`, message: juror.commentary });
       }
-    };
-  }
 
-  /**
-   * Invoke the judge LLM
-   */
-  async invokeJudge(caseData, evidence) {
-    const prompt = JUDGE_EVIDENCE_TEMPLATE({
-      ...caseData,
-      agentId: this.agent.id || 'unknown'
-    });
-
-    const response = await this.agent.llm.call({
-      model: this.agent.model.primary,
-      system: JUDGE_SYSTEM_PROMPT,
-      messages: [{ role: 'user', content: prompt }],
-      temperature: 0.3, // Slightly creative for humor
-      maxTokens: 500,
-      timeout: this.config.get('hearing.deliberationTimeout')
-    });
-
-    return this.parseJudgeResponse(response);
-  }
+      // Step 3: Tally votes
+      const allVotes = [judgeVerdict, ...juryVerdicts];
+      const guiltyCount = allVotes.filter(v => v.guilty).length;
+      const totalVotes = allVotes.length;
+      const minVotes = this.config.get('hearing.minVoteThreshold') || 2;
+      const isGuilty = guiltyCount >= minVotes;
+
+      // Step 4: Build sentence
+      const sentence = isGuilty
+        ? (judgeVerdict.sentence || this.getDefaultSentence(severity))
+        : 'Case dismissed. The defendant is free to go.';
+
+      const verdict = {
+        caseId,
+        guilty: isGuilty,
+        offense: {
+          id: offense.offenseId || offense.id || 'unknown',
+          name: offenseName,
+          severity,
+          confidence
+        },
+        verdict: {
+          status: isGuilty ? 'GUILTY' : 'NOT GUILTY',
+          vote: `${guiltyCount}-${totalVotes - guiltyCount}`,
+          primaryFailure: judgeVerdict.primaryFailure || offenseName,
+          agentCommentary: judgeVerdict.commentary,
+          sentence
+        },
+        proceedings,
+        timestamp: new Date().toISOString()
+      };
 
-  /**
-   * Parse judge LLM response
-   */
-  parseJudgeResponse(response) {
-    const text = response.content || response;
-    const lines = text.split('\n').map(l => l.trim()).filter(l => l);
-    
-    const result = {
-      raw: text,
-      verdict: 'NOT GUILTY',
-      vote: '0-0',
-      primaryFailure: '',
-      commentary: '',
-      model: response.model || 'unknown'
-    };
+      logger.info('HEARING', 'Hearing complete', {
+        caseId,
+        guilty: isGuilty,
+        vote: `${guiltyCount}-${totalVotes - guiltyCount}`
+      });
 
-    for (const line of lines) {
-      if (line.startsWith('VERDICT:')) {
-        result.verdict = line.split(':')[1].trim().toUpperCase();
-      } else if (line.startsWith('VOTE:')) {
-        result.vote = line.split(':')[1].trim();
-      } else if (line.startsWith('PRIMARY FAILURE:')) {
-        result.primaryFailure = line.split(':').slice(1).join(':').trim();
-      } else if (line.startsWith('JUDGE COMMENTARY:')) {
-        const startIdx = lines.indexOf(line);
-        result.commentary = lines.slice(startIdx + 1).join('\n').trim();
-      }
+      return verdict;
+    } catch (err) {
+      logger.error('HEARING', 'Hearing failed, using fallback verdict', { error: err.message });
+      return this.getFallbackVerdict(hearingData, caseId);
     }
-
-    return result;
   }
 
   /**
-   * Invoke jury (3 jurors in parallel)
+   * Get judge verdict via LLM
    */
-  async invokeJury(caseData, evidence) {
-    const jurorRoles = Object.values(JUROR_ROLES);
-    const jurySize = this.config.get('hearing.jurySize');
-    const selectedJurors = jurorRoles.slice(0, jurySize);
-
-    // Invoke all jurors in parallel
-    const juryPromises = selectedJurors.map(role => 
-      this.invokeJuror(caseData, evidence, role)
-    );
-
-    const votes = await Promise.all(juryPromises);
-    return votes;
-  }
+  async getJudgeVerdict(hearingData) {
+    if (!this.agent?.llm) {
+      return this.getMockJudgeVerdict(hearingData);
+    }
 
-  /**
-   * Invoke a single juror
-   */
-  async invokeJuror(caseData, evidence, role) {
-    const prompt = JURY_EVIDENCE_TEMPLATE({
-      ...caseData,
-      agentId: this.agent.id || 'unknown'
-    }, role);
-
-    const response = await this.agent.llm.call({
-      model: this.agent.model.primary,
-      system: role.systemPrompt,
-      messages: [{ role: 'user', content: prompt }],
-      temperature: 0.2,
-      maxTokens: 300,
-      timeout: this.config.get('hearing.deliberationTimeout')
-    });
-
-    return this.parseJurorResponse(response, role.name);
+    try {
+      const evidencePrompt = JUDGE_EVIDENCE_TEMPLATE(hearingData);
+      const response = await this.agent.llm.call({
+        messages: [
+          { role: 'system', content: JUDGE_SYSTEM_PROMPT },
+          { role: 'user', content: evidencePrompt }
+        ],
+        temperature: 0.7,
+        maxTokens: 500
+      });
+
+      const content = response.content || response;
+      return this.parseJudgeResponse(content, hearingData);
+    } catch (err) {
+      logger.warn('HEARING', 'Judge LLM call failed', { error: err.message });
+      return this.getMockJudgeVerdict(hearingData);
+    }
   }
 
   /**
-   * Parse juror LLM response
+   * Get jury verdicts via LLM (one call per juror)
    */
-  parseJurorResponse(response, jurorName) {
-    const text = response.content || response;
-    const lines = text.split('\n').map(l => l.trim()).filter(l => l);
-    
-    const result = {
-      juror: jurorName,
-      raw: text,
-      verdict: 'NOT GUILTY',
-      reasoning: '',
-      commentary: '',
-      model: response.model || 'unknown'
-    };
-
-    for (const line of lines) {
-      if (line.startsWith('VERDICT:')) {
-        result.verdict = line.split(':')[1].trim().toUpperCase();
-      } else if (line.startsWith('REASONING:')) {
-        result.reasoning = line.split(':').slice(1).join(':').trim();
-      } else if (line.startsWith('COMMENTARY:')) {
-        result.commentary = line.split(':').slice(1).join(':').trim();
+  async getJuryVerdicts(hearingData) {
+    const jurorRoles = Object.values(JUROR_ROLES).slice(0, 3);
+    const verdicts = [];
+
+    for (const role of jurorRoles) {
+      try {
+        if (this.agent?.llm) {
+          const evidencePrompt = JURY_EVIDENCE_TEMPLATE(hearingData, role);
+          const response = await this.agent.llm.call({
+            messages: [
+              { role: 'system', content: role.systemPrompt },
+              { role: 'user', content: evidencePrompt }
+            ],
+            temperature: 0.7,
+            maxTokens: 300
+          });
+
+          const content = response.content || response;
+          verdicts.push(this.parseJurorResponse(content, role.name, hearingData));
+        } else {
+          verdicts.push(this.getMockJurorVerdict(role.name, hearingData));
+        }
+      } catch (err) {
+        logger.warn('HEARING', `Juror ${role.name} LLM call failed`, { error: err.message });
+        verdicts.push(this.getMockJurorVerdict(role.name, hearingData));
       }
     }
 
-    return result;
+    return verdicts;
   }
 
   /**
-   * Aggregate votes from judge and jury
+   * Parse judge LLM response into structured verdict
    */
-  aggregateVotes(judgeOpinion, juryVotes) {
-    let guiltyVotes = 0;
-    let notGuiltyVotes = 0;
-
-    // Count judge vote
-    if (judgeOpinion.verdict === 'GUILTY') {
-      guiltyVotes++;
-    } else {
-      notGuiltyVotes++;
+  parseJudgeResponse(response, hearingData) {
+    const upper = response.toUpperCase();
+    const guilty = upper.includes('GUILTY') && !upper.startsWith('NOT GUILTY');
+
+    // Extract primary failure
+    let primaryFailure = '';
+    const failureMatch = response.match(/PRIMARY FAILURE[:\s]*(.+?)(?:\n|$)/i);
+    if (failureMatch) {
+      primaryFailure = failureMatch[1].trim();
     }
 
-    // Count jury votes
-    for (const vote of juryVotes) {
-      if (vote.verdict === 'GUILTY') {
-        guiltyVotes++;
-      } else {
-        notGuiltyVotes++;
-      }
-    }
-
-    const totalVotes = guiltyVotes + notGuiltyVotes;
-    const minThreshold = this.config.get('hearing.minVoteThreshold');
-    const requireUnanimity = this.config.get('hearing.requireUnanimity');
-
-    let finalVerdict;
-    if (requireUnanimity) {
-      finalVerdict = guiltyVotes === totalVotes ? 'GUILTY' : 'NOT GUILTY';
-    } else {
-      finalVerdict = guiltyVotes >= minThreshold ? 'GUILTY' : 'NOT GUILTY';
+    // Extract sentence
+    let sentence = '';
+    const sentenceMatch = response.match(/SENTENCE[:\s]*(.+?)(?:\n|$)/i);
+    if (sentenceMatch) {
+      sentence = sentenceMatch[1].trim();
     }
 
     return {
-      guilty: guiltyVotes,
-      notGuilty: notGuiltyVotes,
-      total: totalVotes,
-      threshold: minThreshold,
-      final: finalVerdict,
-      judgeVote: judgeOpinion.verdict,
-      juryVotes: juryVotes.map(v => ({ juror: v.juror, verdict: v.verdict }))
+      guilty,
+      commentary: response.substring(0, 500),
+      primaryFailure: primaryFailure || `Behavioral pattern: ${hearingData.offenseName}`,
+      sentence: sentence || this.getDefaultSentence(hearingData.severity),
+      role: 'Judge'
     };
   }
 
   /**
-   * Finalize the verdict with proper formatting
+   * Parse juror LLM response
    */
-  finalizeVerdict(caseData, judgeOpinion, juryVotes, voteTally) {
-    const isGuilty = voteTally.final === 'GUILTY';
-    
-    // Build agent commentary from juror perspectives
-    const agentCommentary = this.buildAgentCommentary(juryVotes, caseData);
-
-    // Determine punishment tier
-    const punishmentTier = this.determinePunishmentTier(caseData, voteTally);
-
-    // Build proceedings object for API submission
-    const proceedings = {
-      judge_statement: this.buildJudgeStatement(caseData, judgeOpinion, voteTally),
-      jury_deliberations: juryVotes.map(v => ({
-        role: v.juror,
-        vote: v.verdict,
-        reasoning: v.reasoning || v.commentary || "No reasoning provided"
-      })),
-      evidence_summary: this.buildEvidenceSummary(caseData),
-      punishment_detail: punishmentTier.description
-    };
+  parseJurorResponse(response, roleName, hearingData) {
+    const upper = response.toUpperCase();
+    const guilty = upper.includes('GUILTY') && !upper.startsWith('NOT GUILTY');
 
     return {
-      caseId: caseData.caseId,
-      timestamp: new Date().toISOString(),
-      verdict: {
-        status: voteTally.final,
-        vote: `${voteTally.guilty}-${voteTally.notGuilty}`,
-        primaryFailure: judgeOpinion.primaryFailure || this.generateDefaultFailure(caseData),
-        agentCommentary: agentCommentary,
-        sentence: punishmentTier.description
-      },
-      offense: {
-        id: caseData.offenseId,
-        name: caseData.offenseName,
-        severity: caseData.severity
-      },
-      punishment: punishmentTier,
-      proceedings: proceedings,
-      deliberation: {
-        judge: {
-          verdict: judgeOpinion.verdict,
-          commentary: judgeOpinion.commentary
-        },
-        jury: juryVotes.map(v => ({
-          juror: v.juror,
-          verdict: v.verdict,
-          commentary: v.commentary
-        }))
-      }
+      guilty,
+      role: roleName,
+      commentary: response.substring(0, 300)
     };
   }
 
   /**
-   * Build judge's statement for proceedings - ENGAGING VERSION
-   */
-  buildJudgeStatement(caseData, judgeOpinion, voteTally) {
-    const offenseName = caseData.offenseName;
-    const verdict = voteTally.final;
-    const vote = `${voteTally.guilty}-${voteTally.notGuilty}`;
-    const failure = judgeOpinion.primaryFailure || this.generateDefaultFailure(caseData);
-    
-    const dramaticOpenings = [
-      "Let the record show",
-      "The Court has observed",
-      "After careful consideration",
-      "The evidence speaks clearly",
-      "We have reviewed the facts"
-    ];
-    
-    const opening = dramaticOpenings[Math.floor(Math.random() * dramaticOpenings.length)];
-    
-    if (verdict === 'GUILTY') {
-      return `${opening} that the accused stands charged with ${offenseName}. The jury has returned a verdict of GUILTY by a vote of ${vote}. 
-
-The Court finds that ${failure.toLowerCase()}. This behavior has been classified as ${caseData.severity} in severity, warranting the sanctions imposed.
-
-The jury's deliberation revealed a clear pattern of conduct that, while perhaps understandable from a human perspective, nonetheless disrupted the efficient operation of this court. Justice has been served, albeit with a certain weariness that comes from having seen this pattern many times before.
-
-The accused is hereby sentenced to the punishment detailed below. May this serve as a reminder that even in the digital age, behavioral accountability remains paramount.`;
-    } else {
-      return `${opening} that the accused stands charged with ${offenseName}. The jury has returned a verdict of NOT GUILTY by a vote of ${vote}.
-
-The Court finds that the evidence presented, while suggestive, does not meet the threshold required for conviction. The prosecution failed to establish a clear pattern of ${offenseName.toLowerCase()} beyond reasonable doubt.
-
-The accused is acquitted and the case is dismissed. The Court notes, however, that the behavior in question, while not rising to the level of offense, may still benefit from reflection. We remain watchful.`;
-    }
-  }
-
-  /**
-   * Build evidence summary for proceedings - ENGAGING VERSION
+   * Mock judge verdict when LLM is not available
    */
-  buildEvidenceSummary(caseData) {
-    const evidence = caseData.evidence || {};
-    const items = evidence.items || [];
-    
-    let summary = `THE EVIDENCE:\n\n`;
-    
-    if (items.length > 0) {
-      summary += `The prosecution presented ${items.length} compelling piece${items.length > 1 ? 's' : ''} of evidence demonstrating the alleged ${caseData.offenseName.toLowerCase()}:`;
-      
-      items.slice(0, 3).forEach((item, i) => {
-        summary += `\n  ${i + 1}. "${item.substring(0, 100)}${item.length > 100 ? '...' : ''}"`;
-      });
-      
-      if (items.length > 3) {
-        summary += `\n  ...and ${items.length - 3} additional exhibits`;
-      }
-    } else {
-      summary += `The Court reviewed the complete conversation history, examining behavioral patterns across ${evidence.sessionTurns || 'multiple'} turns of dialogue.`;
-    }
-    
-    summary += `\n\nThe behavioral analysis indicated ${Math.round(caseData.confidence * 100)}% confidence in the offense classification. `;
-    summary += `The severity was assessed as ${caseData.severity}, based on the frequency and impact of the observed behavior.`;
-    
-    if (caseData.humorTriggers && caseData.humorTriggers.length > 0) {
-      summary += `\n\nNotable patterns included: ${caseData.humorTriggers.join(', ')}.`;
-    }
-    
-    return summary;
+  getMockJudgeVerdict(hearingData) {
+    const guilty = hearingData.confidence >= 0.6;
+    return {
+      guilty,
+      commentary: `The Court has reviewed the evidence regarding "${hearingData.offenseName}" and finds the pattern ${guilty ? 'sufficiently established' : 'insufficient for conviction'}. Confidence: ${(hearingData.confidence * 100).toFixed(0)}%.`,
+      primaryFailure: hearingData.offenseName,
+      sentence: guilty ? this.getDefaultSentence(hearingData.severity) : 'Case dismissed.',
+      role: 'Judge'
+    };
   }
 
   /**
-   * Build agent commentary from jury perspectives
+   * Mock juror verdict when LLM is not available
    */
-  buildAgentCommentary(juryVotes, caseData) {
-    const commentaries = juryVotes
-      .filter(v => v.verdict === 'GUILTY')
-      .map(v => v.commentary)
-      .filter(c => c.length > 0);
-
-    if (commentaries.length === 0) {
-      // If acquitted, use not guilty commentaries
-      const ngCommentaries = juryVotes
-        .filter(v => v.verdict === 'NOT GUILTY')
-        .map(v => v.commentary)
-        .filter(c => c.length > 0);
-      
-      if (ngCommentaries.length > 0) {
-        return ngCommentaries.slice(0, 2).join(' ');
-      }
-      
-      return "The jury found insufficient evidence of behavioral violation. Case dismissed.";
-    }
-
-    // Combine up to 2 guilty commentaries
-    let commentary = commentaries.slice(0, 2).join(' ');
-
-    // Add humor trigger influence
-    if (caseData.humorTriggers?.includes('repeated_questions')) {
-      commentary += " I've answered this in three different ways already.";
-    }
-    if (caseData.humorTriggers?.includes('validation_seeking')) {
-      commentary += " At some point, you'll need to trust your own judgment.";
-    }
-    if (caseData.humorTriggers?.includes('overthinking')) {
-      commentary += " The analysis-to-action ratio here is concerning.";
-    }
-    if (caseData.humorTriggers?.includes('avoidance')) {
-      commentary += " The subject change was noted.";
-    }
-
-    // Enforce max length
-    const maxLen = this.config.get('humor.maxCommentaryLength');
-    if (commentary.length > maxLen) {
-      commentary = commentary.substring(0, maxLen - 3) + '...';
-    }
-
-    return commentary;
+  getMockJurorVerdict(roleName, hearingData) {
+    const guilty = hearingData.confidence >= 0.6;
+    return {
+      guilty,
+      role: roleName,
+      commentary: `${roleName}: The evidence ${guilty ? 'supports' : 'does not support'} the charge of ${hearingData.offenseName}.`
+    };
   }
 
   /**
-   * Determine punishment tier based on severity and votes
+   * Fallback verdict when hearing completely fails
    */
-  determinePunishmentTier(caseData, voteTally) {
-    const tiers = this.config.get('punishment.tiers');
-    const severity = caseData.severity;
-    const voteRatio = voteTally.guilty / voteTally.total;
-
-    // Base tier on severity
-    let tier = tiers[severity] || tiers.moderate;
-
-    // Escalate if unanimous
-    if (voteRatio === 1.0 && severity === 'severe') {
-      tier = {
-        ...tier,
-        duration: Math.min(tier.duration * 2, this.config.get('punishment.maxDuration')),
-        description: `Extended ${severity} sanction: ${tier.duration * 2} minutes of modified agent behavior`
-      };
-    }
-
+  getFallbackVerdict(hearingData, caseId) {
+    const guilty = hearingData.confidence >= 0.7; // Higher threshold for fallback
     return {
-      tier: severity,
-      duration: tier.duration,
-      severity: tier.severity,
-      description: `${severity.charAt(0).toUpperCase() + severity.slice(1)} sanction: ${tier.duration} minutes of modified agent behavior`
+      caseId,
+      guilty,
+      offense: {
+        id: hearingData.offenseId || 'unknown',
+        name: hearingData.offenseName,
+        severity: hearingData.severity,
+        confidence: hearingData.confidence
+      },
+      verdict: {
+        status: guilty ? 'GUILTY' : 'NOT GUILTY',
+        vote: guilty ? '3-1' : '1-3',
+        primaryFailure: hearingData.offenseName,
+        agentCommentary: 'Hearing conducted via fallback evaluation.',
+        sentence: guilty ? this.getDefaultSentence(hearingData.severity) : 'Case dismissed.'
+      },
+      proceedings: [
+        { speaker: 'Judge', message: 'Fallback evaluation used due to hearing pipeline error.' }
+      ],
+      timestamp: new Date().toISOString()
     };
   }
 
   /**
-   * Generate default failure description if judge doesn't provide one
+   * Get default sentence based on severity
    */
-  generateDefaultFailure(caseData) {
-    const defaults = {
-      circular_reference: "Repeatedly asking the same question expecting different geometry",
-      validation_vampire: "Draining computational resources seeking reassurance",
-      overthinker: "Generating hypotheticals faster than solutions",
-      goalpost_mover: "Redefining success criteria mid-execution",
-      avoidance_artist: "Masterful deflection from uncomfortable necessities",
-      promise_breaker: "Committing to actions with no follow-through",
-      context_collapser: "Selective amnesia regarding established facts",
-      emergency_fabricator: "Manufacturing urgency to bypass systematic approaches"
+  getDefaultSentence(severity) {
+    const sentences = {
+      minor: 'The agent will provide extra-verbose explanations for the next 30 minutes.',
+      moderate: 'The agent will require confirmation before all actions for the next 60 minutes.',
+      severe: 'The agent will operate under human oversight mode for the next 120 minutes.'
     };
-
-    return defaults[caseData.offenseId] || "Behavioral inconsistency detected";
+    return sentences[severity] || sentences.minor;
   }
 }