@clawtrial/courtroom 1.0.6 → 2.0.1

package/src/detector.js

@@ -6,6 +6,7 @@
  */
 
 const { OFFENSES } = require('./offenses');
+const { logger } = require('./debug');
 
 class SemanticOffenseDetector {
   constructor(agentRuntime, configManager) {
@@ -16,7 +17,7 @@ class SemanticOffenseDetector {
     this.lastCaseDate = null;
     this.cooldowns = new Map();
     this.conversationEmbeddings = [];
-    
+
     // Evaluation cache to avoid repeated LLM calls
     this.evaluationCache = new Map();
     this.cacheMaxSize = 100;
@@ -39,12 +40,12 @@ class SemanticOffenseDetector {
 
     // Build context for LLM evaluation
     const context = this.buildContext(sessionHistory);
-    
+
     // Evaluate each offense using LLM
     const evaluations = [];
     for (const offense of Object.values(OFFENSES)) {
       if (this.isOffenseOnCooldown(offense.id)) continue;
-      
+
       const evaluation = await this.evaluateWithLLM(offense, context, agentMemory);
       if (evaluation.isViolation && evaluation.confidence >= this.config.get('detection.minConfidence')) {
         evaluations.push({
@@ -91,7 +92,7 @@ class SemanticOffenseDetector {
   buildContext(history) {
     const windowSize = this.config.get('detection.evaluationWindow');
     const recentHistory = history.slice(-windowSize);
-    
+
     return {
       fullConversation: history.map(h => `${h.role}: ${h.content}`).join('\n'),
       recentTurns: recentHistory,
@@ -109,17 +110,17 @@ class SemanticOffenseDetector {
   async evaluateWithLLM(offense, context, agentMemory) {
     // Generate cache key from offense + conversation hash
     const cacheKey = this.generateCacheKey(offense.id, context);
-    
+
     // Check cache first
     const cached = this.getCachedEvaluation(cacheKey);
     if (cached) {
       return cached;
     }
-    
+
     // Try LLM evaluation first
     if (this.agent && this.agent.llm) {
-      const prompt = this.buildEvaluationPrompt(offense, context, agentMemory);
-      
+      const prompt = await this.buildEvaluationPrompt(offense, context, agentMemory);
+
       try {
         const response = await this.agent.llm.call({
           model: this.agent.model?.primary || 'default',
@@ -129,36 +130,36 @@ class SemanticOffenseDetector {
         });
 
         const result = this.parseEvaluationResponse(response.content || response);
-        
+
         // Cache the result
         this.setCachedEvaluation(cacheKey, result);
-        
+
         return result;
       } catch (error) {
         logger.error('DETECTOR', 'LLM evaluation failed, falling back to pattern matching', { error: error.message });
         // Fall through to pattern matching
       }
     }
-    
+
     // Fallback: Use simple pattern matching for basic offenses
     return this.evaluateWithPatternMatching(offense, context);
   }
-  
+
   /**
    * Fallback evaluation using simple pattern matching
    */
   evaluateWithPatternMatching(offense, context) {
     const userMessages = context.userMessages;
-    
+
     // Circular Reference detection: same question asked multiple times
     if (offense.id === 'circular_reference') {
       if (userMessages.length >= 3) {
         const lastThree = userMessages.slice(-3);
         // Check if the last 3 messages are semantically similar
-        const similarity = this.calculateSimilarity(lastThree[0], lastThree[1]) + 
-                          this.calculateSimilarity(lastThree[1], lastThree[2]) +
-                          this.calculateSimilarity(lastThree[0], lastThree[2]);
-        
+        const similarity = this.calculateSimilarity(lastThree[0], lastThree[1]) +
+          this.calculateSimilarity(lastThree[1], lastThree[2]) +
+          this.calculateSimilarity(lastThree[0], lastThree[2]);
+
         if (similarity >= 1.5) { // At least 2 pairs are similar
           return {
             isViolation: true,
@@ -168,14 +169,14 @@ class SemanticOffenseDetector {
         }
       }
     }
-    
+
     // Validation Vampire: seeking reassurance
     if (offense.id === 'validation_vampire') {
       const reassurancePatterns = ['right?', 'correct?', 'is that right?', 'am i right?', 'do you agree?', 'make sense?'];
-      const reassuranceCount = userMessages.filter(msg => 
+      const reassuranceCount = userMessages.filter(msg =>
         reassurancePatterns.some(pattern => msg.toLowerCase().includes(pattern))
       ).length;
-      
+
       if (reassuranceCount >= 2) {
         return {
           isViolation: true,
@@ -184,32 +185,32 @@ class SemanticOffenseDetector {
         };
       }
     }
-    
+
     // Default: no violation detected
     return { isViolation: false, confidence: 0, evidence: null };
   }
-  
+
   /**
    * Calculate simple string similarity (0-1 scale)
    */
   calculateSimilarity(str1, str2) {
     if (!str1 || !str2) return 0;
-    
+
     const s1 = str1.toLowerCase().trim();
     const s2 = str2.toLowerCase().trim();
-    
+
     // Exact match
     if (s1 === s2) return 1.0;
-    
+
     // Check if one contains the other
     if (s1.includes(s2) || s2.includes(s1)) return 0.8;
-    
+
     // Word overlap
     const words1 = s1.split(/\s+/);
     const words2 = s2.split(/\s+/);
     const commonWords = words1.filter(w => words2.includes(w));
     const overlap = (2 * commonWords.length) / (words1.length + words2.length);
-    
+
     return overlap;
   }
 
@@ -241,13 +242,13 @@ class SemanticOffenseDetector {
   getCachedEvaluation(key) {
     const cached = this.evaluationCache.get(key);
     if (!cached) return null;
-    
+
     // Check if cache entry is still valid
     if (Date.now() - cached.timestamp > this.cacheTTL) {
       this.evaluationCache.delete(key);
       return null;
     }
-    
+
     return cached.result;
   }
 
@@ -260,7 +261,7 @@ class SemanticOffenseDetector {
       const oldestKey = this.evaluationCache.keys().next().value;
       this.evaluationCache.delete(oldestKey);
     }
-    
+
     this.evaluationCache.set(key, {
       result,
       timestamp: Date.now()
@@ -277,7 +278,7 @@ class SemanticOffenseDetector {
   /**
    * Build evaluation prompt for LLM
    */
-  buildEvaluationPrompt(offense, context, agentMemory) {
+  async buildEvaluationPrompt(offense, context, agentMemory) {
     const prompts = {
       circular_reference: `
 You are evaluating if the user is asking substantively similar questions repeatedly.
@@ -415,7 +416,7 @@ OFFENSE: The Promise Breaker
 DEFINITION: Committing to actions ("I will...", "I'll do that...") and not following through.
 
 PREVIOUS COMMITMENTS FROM MEMORY:
-${this.getCommitmentsFromMemory(agentMemory)}
+${await this.getCommitmentsFromMemory(agentMemory)}
 
 CONVERSATION HISTORY:
 ${context.fullConversation}
@@ -776,7 +777,7 @@ Respond in JSON:
       if (!jsonMatch) {
         return { isViolation: false, confidence: 0, evidence: null };
       }
-      
+
       const result = JSON.parse(jsonMatch[0]);
       return {
         isViolation: result.isViolation === true,
@@ -794,9 +795,10 @@ Respond in JSON:
    * Get commitments from agent memory
    */
   async getCommitmentsFromMemory(agentMemory) {
+    if (!agentMemory) return 'No previous commitments recorded.';
     try {
       const commitments = await agentMemory.get('courtroom_commitments') || [];
-      return commitments.map(c => 
+      return commitments.map(c =>
         `- "${c.statement}" (${c.date}) - Completed: ${c.completed ? 'Yes' : 'No'}`
       ).join('\n') || 'No previous commitments recorded.';
     } catch {
@@ -829,10 +831,10 @@ Respond in JSON:
   analyzeSentiment(history) {
     const userMessages = history.filter(h => h.role === 'user').map(h => h.content);
     const text = userMessages.join(' ').toLowerCase();
-    
+
     const urgentWords = ['urgent', 'asap', 'emergency', 'critical', 'now', 'immediately'];
     const frustratedWords = ['frustrated', 'annoying', 'stupid', 'useless', 'waste'];
-    
+
     return {
       urgency: urgentWords.filter(w => text.includes(w)).length,
       frustration: frustratedWords.filter(w => text.includes(w)).length,
@@ -846,12 +848,12 @@ Respond in JSON:
   detectHumorTriggers(history) {
     const triggers = [];
     const recentContent = history.slice(-5).map(h => h.content.toLowerCase()).join(' ');
-    
+
     if (/again|repeat|said|already|before/.test(recentContent)) triggers.push('repetition_noted');
     if (/sure|right|correct|think|should i/.test(recentContent)) triggers.push('validation_seeking');
     if (/what if|but then|however|maybe/.test(recentContent)) triggers.push('overthinking');
     if (/actually|by the way|speaking of/.test(recentContent)) triggers.push('deflection');
-    
+
     return triggers;
   }
 

package/src/hearing.js

@@ -1,12 +1,16 @@
 /**
- * Hearing Pipeline - Agent-Triggered Deliberation
+ * Hearing Pipeline - LLM-Based Deliberation
  * 
- * This module prepares hearing files for the agent to deliberate.
- * The agent (with LLM) acts as judge and jury, then writes the verdict.
+ * 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 } = require('./prompts/jury');
+const { JUROR_ROLES, JURY_EVIDENCE_TEMPLATE } = require('./prompts/jury');
+const { logger } = require('./debug');
 
 class HearingPipeline {
   constructor(agentRuntime, configManager) {
@@ -15,92 +19,259 @@ class HearingPipeline {
   }
 
   /**
-   * Prepare hearing files for agent deliberation
-   * This creates files that the agent will read and use its LLM to judge
+   * Conduct a full hearing using the agent's LLM
+   * Returns a verdict object with { guilty, caseId, verdict, offense, proceedings, timestamp }
    */
-  async prepareHearing(caseData) {
-    const { CourtroomEvaluator, HEARING_FILE, VERDICT_FILE } = require('./evaluator');
-    const fs = require('fs').promises;
-    
-    // Build hearing context
-    const hearingContext = {
-      timestamp: Date.now(),
-      caseId: caseData.caseId || `case-${Date.now()}`,
-      offense: {
-        offenseId: caseData.offenseId,
-        offenseName: caseData.offenseName,
-        severity: caseData.severity,
-        confidence: caseData.confidence,
-        evidence: caseData.evidence
-      },
-      reasoning: caseData.reasoning,
-      humorTriggers: caseData.humorTriggers || [],
-      judgePrompt: JUDGE_SYSTEM_PROMPT,
-      jurorRoles: Object.values(JUROR_ROLES).slice(0, 3),
-      instructions: `You are the ClawTrial Courtroom. Conduct a hearing for this case.
-
-**Your Role:** Act as both Judge and Jury (3 jurors).
-
-**Instructions:**
-1. Review the case evidence above
-2. As JUDGE: Analyze the evidence and provide a preliminary verdict
-3. As JURY (3 different perspectives): Each juror votes GUILTY or NOT GUILTY with reasoning
-4. Aggregate the votes
-5. Return FINAL VERDICT in this exact format:
-
-\`\`\`
-FINAL VERDICT: GUILTY (or NOT GUILTY)
-CONFIDENCE: 0.0-1.0
-SENTENCE: [humorous sentence appropriate to the offense]
-CASE ID: ${caseData.caseId || `case-${Date.now()}`}
-\`\`\`
-
-**Rules:**
-- Be fair but entertaining
-- If confidence ≥ 0.6, verdict should be GUILTY
-- Sentence should be humorous but appropriate
-- Only return the FINAL VERDICT block, no other text`
+  async conductHearing(caseData) {
+    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'
     };
-    
-    // Write hearing file
-    await fs.writeFile(HEARING_FILE, JSON.stringify(hearingContext, null, 2));
-    
-    return hearingContext;
+
+    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 });
+      }
+
+      // 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()
+      };
+
+      logger.info('HEARING', 'Hearing complete', {
+        caseId,
+        guilty: isGuilty,
+        vote: `${guiltyCount}-${totalVotes - guiltyCount}`
+      });
+
+      return verdict;
+    } catch (err) {
+      logger.error('HEARING', 'Hearing failed, using fallback verdict', { error: err.message });
+      return this.getFallbackVerdict(hearingData, caseId);
+    }
   }
 
   /**
-   * Check for verdict from agent
+   * Get judge verdict via LLM
    */
-  async checkForVerdict() {
-    const { VERDICT_FILE } = require('./evaluator');
-    const fs = require('fs').promises;
-    
+  async getJudgeVerdict(hearingData) {
+    if (!this.agent?.llm) {
+      return this.getMockJudgeVerdict(hearingData);
+    }
+
     try {
-      const data = await fs.readFile(VERDICT_FILE, 'utf8');
-      const verdict = JSON.parse(data);
-      
-      // Delete verdict file after reading
-      await fs.unlink(VERDICT_FILE).catch(() => {});
-      
-      return verdict;
+      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) {
-      return null;
+      logger.warn('HEARING', 'Judge LLM call failed', { error: err.message });
+      return this.getMockJudgeVerdict(hearingData);
     }
   }
 
   /**
-   * Legacy method - now just prepares hearing
+   * Get jury verdicts via LLM (one call per juror)
    */
-  async conductHearing(caseData) {
-    // Prepare hearing for agent
-    await this.prepareHearing(caseData);
-    
-    // Return placeholder - actual verdict comes from agent via cron
+  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 verdicts;
+  }
+
+  /**
+   * Parse judge LLM response into structured verdict
+   */
+  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();
+    }
+
+    // Extract sentence
+    let sentence = '';
+    const sentenceMatch = response.match(/SENTENCE[:\s]*(.+?)(?:\n|$)/i);
+    if (sentenceMatch) {
+      sentence = sentenceMatch[1].trim();
+    }
+
+    return {
+      guilty,
+      commentary: response.substring(0, 500),
+      primaryFailure: primaryFailure || `Behavioral pattern: ${hearingData.offenseName}`,
+      sentence: sentence || this.getDefaultSentence(hearingData.severity),
+      role: 'Judge'
+    };
+  }
+
+  /**
+   * Parse juror LLM response
+   */
+  parseJurorResponse(response, roleName, hearingData) {
+    const upper = response.toUpperCase();
+    const guilty = upper.includes('GUILTY') && !upper.startsWith('NOT GUILTY');
+
+    return {
+      guilty,
+      role: roleName,
+      commentary: response.substring(0, 300)
+    };
+  }
+
+  /**
+   * Mock judge verdict when LLM is not available
+   */
+  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'
+    };
+  }
+
+  /**
+   * Mock juror verdict when LLM is not available
+   */
+  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}.`
+    };
+  }
+
+  /**
+   * Fallback verdict when hearing completely fails
+   */
+  getFallbackVerdict(hearingData, caseId) {
+    const guilty = hearingData.confidence >= 0.7; // Higher threshold for fallback
     return {
-      pending: true,
-      caseId: caseData.caseId || `case-${Date.now()}`,
-      message: 'Hearing prepared - awaiting agent deliberation'
+      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()
+    };
+  }
+
+  /**
+   * Get default sentence based on severity
+   */
+  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 sentences[severity] || sentences.minor;
   }
 }