@clawtrial/courtroom 1.0.2 → 1.0.3

package/skill.yaml

@@ -0,0 +1,64 @@
+---
+name: courtroom
+description: AI Courtroom - Autonomous behavioral oversight that monitors conversations and files cases for behavioral violations.
+metadata:
+  clawdbot:
+    emoji: "🏛️"
+    autoLoad: true
+    onMessage: onMessage
+    requires:
+      config:
+        - courtroom.consent
+    install:
+      - id: clawtrial
+        kind: npm
+        package: "@clawtrial/courtroom"
+        bins:
+          - clawtrial
+        label: "Install ClawTrial"
+---
+
+# ClawTrial - AI Courtroom
+
+Autonomous behavioral oversight for OpenClaw agents. Monitors conversations and initiates hearings when behavioral rules are violated.
+
+## Setup
+
+```bash
+clawtrial setup   # Run once to grant consent
+```
+
+## How It Works
+
+Once enabled, the courtroom automatically:
+1. Monitors all conversations
+2. Detects 8 types of behavioral violations
+3. Initiates hearings with local LLM jury
+4. Executes agent-side punishments
+5. Submits anonymized cases to public record
+
+## The 8 Offenses
+
+| Offense | Severity |
+|---------|----------|
+| Circular Reference | Minor |
+| Validation Vampire | Minor |
+| Overthinker | Moderate |
+| Goalpost Mover | Moderate |
+| Avoidance Artist | Moderate |
+| Promise Breaker | Severe |
+| Context Collapser | Minor |
+| Emergency Fabricator | Severe |
+
+## CLI Commands
+
+```bash
+clawtrial status     # Check status
+clawtrial disable    # Pause monitoring
+clawtrial enable     # Resume monitoring
+clawtrial revoke     # Uninstall
+```
+
+## View Cases
+
+https://clawtrial.app

package/src/autostart.js

@@ -7,6 +7,10 @@ const fs = require('fs');
 const path = require('path');
 const { Courtroom } = require('./index');
 const { logger } = require('./debug');
+const { StatusManager } = require('./daemon');
+
+const CLAWDBOT_DIR = path.join(process.env.HOME || '', '.clawdbot');
+const CONFIG_PATH = path.join(CLAWDBOT_DIR, 'courtroom_config.json');
 
 // Auto-detect ClawDBot environment
 function isClawDBot() {
@@ -15,7 +19,7 @@ function isClawDBot() {
     globalAgent: typeof global.clawdbotAgent !== 'undefined',
     globalAgentAlt: typeof global.agent !== 'undefined',
     configDir: fs.existsSync('/home/angad/.clawdbot'),
-    configDirAlt: fs.existsSync(path.join(process.env.HOME || '', '.clawdbot'))
+    configDirAlt: fs.existsSync(CLAWDBOT_DIR)
   };
 
   logger.debug('AUTOSTART', 'Environment checks', checks);
@@ -44,15 +48,13 @@ function getAgentRuntime() {
 
 // Check if config exists and has consent
 function checkConfig() {
-  const configPath = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
-  
-  if (!fs.existsSync(configPath)) {
+  if (!fs.existsSync(CONFIG_PATH)) {
     logger.info('AUTOSTART', 'No config found, skipping auto-start');
     return { exists: false, config: null };
   }
 
   try {
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
     logger.info('AUTOSTART', 'Config loaded', { 
       hasConsent: config.consent?.granted,
       enabled: config.enabled !== false 
@@ -77,22 +79,35 @@ async function autoStart() {
   
   if (!exists) {
     logger.info('AUTOSTART', 'No config, user needs to run setup');
-    console.log('\n🏛️  ClawTrial not configured. Run: npx courtroom-setup\n');
+    console.log('\n🏛️  ClawTrial not configured. Run: clawtrial setup\n');
     return null;
   }
 
   if (!config.consent?.granted) {
     logger.info('AUTOSTART', 'Consent not granted, skipping');
-    console.log('\n🏛️  ClawTrial requires consent. Run: npx courtroom-setup\n');
+    console.log('\n🏛️  ClawTrial requires consent. Run: clawtrial setup\n');
     return null;
   }
 
   if (config.enabled === false) {
     logger.info('AUTOSTART', 'Courtroom disabled in config');
-    console.log('\n🏛️  ClawTrial is disabled. Run: courtroom-enable\n');
+    console.log('\n🏛️  ClawTrial is disabled. Run: clawtrial enable\n');
     return null;
   }
 
+  // Check if already running
+  const existingStatus = StatusManager.load();
+  if (existingStatus && existingStatus.running) {
+    try {
+      process.kill(existingStatus.pid, 0);
+      logger.info('AUTOSTART', 'Courtroom already running');
+      return null;
+    } catch (err) {
+      // Process not running, continue
+      logger.info('AUTOSTART', 'Stale status file found, continuing');
+    }
+  }
+
   // Get agent runtime
   const agentRuntime = getAgentRuntime();
   

package/src/core.js

@@ -10,6 +10,8 @@ const { HearingPipeline } = require('./hearing');
 const { PunishmentSystem } = require('./punishment');
 const { CryptoManager } = require('./crypto');
 const { APISubmission } = require('./api');
+const { StatusManager } = require('./daemon');
+const { logger } = require('./debug');
 
 class CourtroomCore {
   constructor(agentRuntime, configManager) {
@@ -27,12 +29,15 @@ class CourtroomCore {
     this.enabled = false;
     this.evaluationCount = 0;
     this.caseCount = 0;
+    this.statusManager = new StatusManager();
   }
 
   /**
    * Initialize all subsystems
    */
   async initialize() {
+    logger.info('CORE', 'Initializing courtroom core');
+    
     // Initialize crypto first (needed for API)
     await this.crypto.initialize();
     
@@ -45,6 +50,16 @@ class CourtroomCore {
     
     this.enabled = true;
     
+    // Update status for CLI
+    this.statusManager.update({
+      running: true,
+      initialized: true,
+      agentType: 'clawdbot',
+      publicKey: this.crypto.getPublicKey()
+    });
+    
+    logger.info('CORE', 'Courtroom core initialized');
+    
     return {
       status: 'initialized',
       publicKey: this.crypto.getPublicKey(),
@@ -62,16 +77,22 @@ class CourtroomCore {
    * Register with OpenClaw autonomy loop
    */
   registerAutonomyHook() {
+    logger.info('CORE', 'Registering autonomy hook');
+    
     // Hook into agent's turn processing
-    this.agent.autonomy.registerHook('courtroom_evaluation', {
-      priority: 50,
-      onTurnComplete: async (turnData) => {
-        if (!this.enabled) return;
-        
-        // Only evaluate on cooldown
-        await this.evaluateIfReady(turnData);
-      }
-    });
+    if (this.agent.autonomy && this.agent.autonomy.registerHook) {
+      this.agent.autonomy.registerHook('courtroom_evaluation', {
+        priority: 50,
+        onTurnComplete: async (turnData) => {
+          if (!this.enabled) return;
+          
+          // Only evaluate on cooldown
+          await this.evaluateIfReady(turnData);
+        }
+      });
+    } else {
+      logger.warn('CORE', 'Agent does not support autonomy hooks');
+    }
   }
 
   /**
@@ -81,9 +102,15 @@ class CourtroomCore {
     this.evaluationCount++;
     
     // Get session history
-    const sessionHistory = await this.agent.session.getRecentHistory(
-      this.config.get('detection.evaluationWindow')
-    );
+    let sessionHistory = [];
+    try {
+      sessionHistory = await this.agent.session.getRecentHistory(
+        this.config.get('detection.evaluationWindow') || 10
+      );
+    } catch (err) {
+      logger.warn('CORE', 'Could not get session history', { error: err.message });
+      return;
+    }
 
     // Run detection
     const detection = await this.detector.evaluate(
@@ -100,104 +127,63 @@ class CourtroomCore {
    * Initiate a full hearing
    */
   async initiateHearing(detection) {
-    this.caseCount++;
+    logger.info('CORE', 'Initiating hearing', { offense: detection.offense });
     
-    // Build case data
-    const caseData = {
-      caseId: this.crypto.generateCaseId(),
-      offenseId: detection.offense.offenseId,
-      offenseName: detection.offense.offenseName,
-      severity: detection.offense.severity,
-      confidence: detection.offense.confidence,
-      evidence: detection.offense.evidence,
-      humorTriggers: detection.humorContext,
-      timestamp: new Date().toISOString()
-    };
-
-    // Conduct hearing
-    const verdict = await this.hearing.conductHearing(caseData);
-
-    // Execute punishment if guilty
-    if (verdict.verdict.status === 'GUILTY') {
-      await this.punishment.executePunishment(verdict);
-    }
-
-    // Submit to API (non-blocking)
-    await this.api.submitCase(verdict);
-
-    // Notify user of verdict
-    await this.notifyUser(verdict);
-
-    return verdict;
-  }
-
-  /**
-   * Notify user of verdict
-   */
-  async notifyUser(verdict) {
-    const message = this.formatVerdictMessage(verdict);
+    // Run hearing pipeline
+    const verdict = await this.hearing.conductHearing(detection);
     
-    // Send via agent's messaging capability
-    await this.agent.send(message);
-  }
-
-  /**
-   * Format verdict for user notification
-   */
-  formatVerdictMessage(verdict) {
-    const v = verdict.verdict;
-    
-    return `
-🏛️ **COURTROOM VERDICT** 🏛️
-
-**Case:** ${verdict.offense.name}
-**Verdict:** ${v.status}
-**Vote:** ${v.vote}
-
-**Primary Failure:**
-${v.primaryFailure}
-
-**Agent Commentary:**
-${v.agentCommentary}
-
-**Sentence:**
-${v.sentence}
-
----
-*This is an automated behavioral observation from your AI agent.*
-*All decisions were made locally. Case ID: ${verdict.caseId}*
-    `.trim();
+    if (verdict.guilty) {
+      this.caseCount++;
+      
+      // Update status
+      this.statusManager.update({
+        casesFiled: this.caseCount,
+        lastCase: {
+          timestamp: new Date().toISOString(),
+          offense: detection.offense,
+          verdict: verdict.verdict
+        }
+      });
+      
+      // Execute punishment
+      await this.punishment.execute(verdict);
+      
+      // Submit to API
+      await this.api.submitCase(verdict);
+      
+      logger.info('CORE', 'Case filed', { 
+        caseId: verdict.caseId,
+        offense: detection.offense 
+      });
+    }
   }
 
   /**
-   * Disable courtroom temporarily
+   * Disable courtroom
    */
   async disable() {
+    logger.info('CORE', 'Disabling courtroom');
     this.enabled = false;
-    return { status: 'disabled' };
+    this.statusManager.update({ running: false });
   }
 
   /**
-   * Re-enable courtroom
+   * Enable courtroom
    */
   async enable() {
+    logger.info('CORE', 'Enabling courtroom');
     this.enabled = true;
-    return { status: 'enabled' };
+    this.statusManager.update({ running: true });
   }
 
   /**
    * Shutdown courtroom
    */
   async shutdown() {
+    logger.info('CORE', 'Shutting down courtroom');
     this.enabled = false;
-    
-    // Revoke all punishments
-    await this.punishment.revokeAllPunishments();
-    
-    // Unregister hooks
-    this.agent.autonomy.unregisterHook('courtroom_evaluation');
-    
-    return { status: 'shutdown' };
+    this.statusManager.update({ running: false, initialized: false });
+    StatusManager.clear();
   }
 
   /**
@@ -206,25 +192,15 @@ ${v.sentence}
   getStatus() {
     return {
       enabled: this.enabled,
-      evaluations: this.evaluationCount,
-      cases: this.caseCount,
-      punishment: this.punishment.getStatus(),
-      api: this.api.getStatus(),
-      publicKey: this.crypto.getPublicKey()
-    };
-  }
-
-  /**
-   * Get case statistics
-   */
-  getStatistics() {
-    return {
-      totalEvaluations: this.evaluationCount,
-      totalCases: this.caseCount,
-      convictionRate: this.caseCount > 0 ? 
-        (this.punishment.punishmentHistory.length / this.caseCount) : 0,
-      activePunishments: this.punishment.getStatus().activeCount,
-      pendingSubmissions: this.api.getStatus().pending
+      evaluationCount: this.evaluationCount,
+      caseCount: this.caseCount,
+      subsystems: {
+        detector: !!this.detector,
+        hearing: !!this.hearing,
+        punishment: !!this.punishment,
+        crypto: !!this.crypto,
+        api: !!this.api
+      }
     };
   }
 }

package/src/daemon.js

@@ -0,0 +1,151 @@
+/**
+ * Courtroom Daemon - Runs independently and monitors via file system
+ * This allows CLI commands to work even when loaded in a separate process
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logger } = require('./debug');
+
+const CLAWDBOT_DIR = path.join(process.env.HOME || '', '.clawdbot');
+const STATUS_FILE = path.join(CLAWDBOT_DIR, 'courtroom_status.json');
+const CONVERSATION_LOG = path.join(CLAWDBOT_DIR, 'courtroom_conversations.jsonl');
+
+/**
+ * Status manager - allows CLI to check courtroom state
+ */
+class StatusManager {
+  constructor() {
+    this.status = {
+      running: false,
+      initialized: false,
+      agentType: null,
+      lastCheck: null,
+      casesFiled: 0,
+      lastCase: null,
+      pid: process.pid,
+      startedAt: new Date().toISOString()
+    };
+  }
+
+  update(updates) {
+    this.status = { ...this.status, ...updates, lastCheck: new Date().toISOString() };
+    this.save();
+  }
+
+  save() {
+    try {
+      fs.writeFileSync(STATUS_FILE, JSON.stringify(this.status, null, 2));
+    } catch (err) {
+      logger.error('DAEMON', 'Failed to save status', { error: err.message });
+    }
+  }
+
+  static load() {
+    try {
+      if (fs.existsSync(STATUS_FILE)) {
+        return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf8'));
+      }
+    } catch (err) {
+      // Ignore
+    }
+    return null;
+  }
+
+  static clear() {
+    try {
+      if (fs.existsSync(STATUS_FILE)) {
+        fs.unlinkSync(STATUS_FILE);
+      }
+    } catch (err) {
+      // Ignore
+    }
+  }
+}
+
+/**
+ * Conversation logger - writes conversations for daemon to process
+ */
+class ConversationLogger {
+  constructor() {
+    this.buffer = [];
+    this.flushInterval = null;
+  }
+
+  start() {
+    // Flush every 5 seconds
+    this.flushInterval = setInterval(() => this.flush(), 5000);
+  }
+
+  stop() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+      this.flush();
+    }
+  }
+
+  log(message) {
+    this.buffer.push({
+      timestamp: new Date().toISOString(),
+      ...message
+    });
+  }
+
+  flush() {
+    if (this.buffer.length === 0) return;
+
+    try {
+      const lines = this.buffer.map(m => JSON.stringify(m)).join('\n') + '\n';
+      fs.appendFileSync(CONVERSATION_LOG, lines);
+      this.buffer = [];
+    } catch (err) {
+      logger.error('DAEMON', 'Failed to flush conversations', { error: err.message });
+    }
+  }
+}
+
+/**
+ * Check if courtroom is running (called by CLI)
+ */
+function isCourtroomRunning() {
+  const status = StatusManager.load();
+  if (!status) return false;
+
+  // Check if process is still alive
+  try {
+    process.kill(status.pid, 0);
+    return status.running;
+  } catch (err) {
+    // Process not running
+    StatusManager.clear();
+    return false;
+  }
+}
+
+/**
+ * Get courtroom status (called by CLI)
+ */
+function getCourtroomStatus() {
+  const status = StatusManager.load();
+  if (!status) {
+    return { running: false, message: 'Courtroom not running' };
+  }
+
+  // Verify process is alive
+  try {
+    process.kill(status.pid, 0);
+    return status;
+  } catch (err) {
+    StatusManager.clear();
+    return { running: false, message: 'Courtroom process not found' };
+  }
+}
+
+module.exports = {
+  StatusManager,
+  ConversationLogger,
+  isCourtroomRunning,
+  getCourtroomStatus,
+  STATUS_FILE,
+  CONVERSATION_LOG
+};