@clawtrial/courtroom 1.0.3 → 2.0.0

package/src/consent.js

@@ -1,215 +0,0 @@
-/**
- * Consent Management System
- * 
- * Handles installation, consent recording, and permission enumeration.
- * Consent is enforced at runtime and can be revoked at any time.
- */
-
-const { createHash, randomUUID } = require('crypto');
-
-const CONSENT_VERSION = '1.0.0';
-
-const REQUIRED_ACKNOWLEDGMENTS = [
-  {
-    id: 'autonomy',
-    text: 'I understand the agent will autonomously monitor my behavior and initiate hearings without my explicit request',
-    required: true
-  },
-  {
-    id: 'local_only',
-    text: 'I understand all verdicts and punishments are computed locally by the agent and no central authority is involved',
-    required: true
-  },
-  {
-    id: 'agent_controlled',
-    text: 'I understand punishments affect only the agent\'s behavior and cannot coerce or harm me',
-    required: true
-  },
-  {
-    id: 'reversible',
-    text: 'I understand all punishments are time-bound, reversible, and I can disable the system at any time',
-    required: true
-  },
-  {
-    id: 'api_submission',
-    text: 'I understand anonymized case summaries may be sent to an external API for display purposes only',
-    required: true
-  },
-  {
-    id: 'entertainment',
-    text: 'I understand this system is entertainment-first and not a substitute for professional advice',
-    required: true
-  }
-];
-
-const REQUESTED_PERMISSIONS = [
-  {
-    name: 'memory_access',
-    description: 'Read agent memory, logs, and task history',
-    scope: 'agent_only',
-    required: true
-  },
-  {
-    name: 'behavioral_monitoring',
-    description: 'Monitor interaction patterns and detect behavioral patterns',
-    scope: 'session',
-    required: true
-  },
-  {
-    name: 'llm_invocation',
-    description: 'Invoke LLM calls for judge and jury deliberations',
-    scope: 'agent_only',
-    required: true
-  },
-  {
-    name: 'policy_override',
-    description: 'Temporarily modify agent behavior policies during punishment periods',
-    scope: 'agent_only',
-    required: true
-  },
-  {
-    name: 'network_submission',
-    description: 'Submit signed case summaries to external API',
-    scope: 'outbound_only',
-    required: true
-  },
-  {
-    name: 'key_storage',
-    description: 'Generate and store cryptographic keypair for API authentication',
-    scope: 'local_storage',
-    required: true
-  }
-];
-
-class ConsentManager {
-  constructor(agentRuntime, configManager) {
-    this.agent = agentRuntime;
-    this.config = configManager;
-    this.consentKey = 'courtroom_consent_v1';
-  }
-
-  /**
-   * Present the consent form to the user
-   */
-  async presentConsentForm() {
-    return {
-      version: CONSENT_VERSION,
-      title: 'AI Courtroom - Consent Required',
-      description: `The AI Courtroom is an autonomous behavioral oversight system that monitors 
-agent-human interactions and initiates simulated "hearings" when behavioral patterns suggest 
-inconsistency, avoidance, or self-sabotage. All decisions are made locally by your agent.`,
-      acknowledgments: REQUIRED_ACKNOWLEDGMENTS,
-      permissions: REQUESTED_PERMISSIONS,
-      instructions: {
-        grant: 'Call courtroom.grantConsent({ autonomy: true, local_only: true, ... }) with all required acknowledgments set to true',
-        revoke: 'Call courtroom.revokeConsent() at any time to disable the system',
-        disable: 'Call courtroom.disable() to temporarily pause without revoking consent'
-      },
-      warnings: [
-        'This system is ENTERTAINMENT-FIRST and should not be taken as professional advice',
-        'The agent may become less helpful during punishment periods',
-        'Case summaries are anonymized but may contain behavioral patterns'
-      ]
-    };
-  }
-
-  /**
-   * Grant consent with explicit acknowledgments
-   */
-  async grantConsent(acknowledgments) {
-    // Verify all required acknowledgments are present and true
-    for (const req of REQUIRED_ACKNOWLEDGMENTS) {
-      if (req.required && !acknowledgments[req.id]) {
-        throw new Error(`Missing required acknowledgment: ${req.id}`);
-      }
-    }
-
-    const consentRecord = {
-      version: CONSENT_VERSION,
-      grantedAt: new Date().toISOString(),
-      acknowledgments,
-      permissions: REQUESTED_PERMISSIONS.filter(p => p.required).map(p => p.name),
-      consentId: randomUUID(),
-      hash: null // Will be computed
-    };
-
-    // Create tamper-evident hash
-    const hashInput = JSON.stringify({
-      id: consentRecord.consentId,
-      grantedAt: consentRecord.grantedAt,
-      acks: acknowledgments
-    });
-    consentRecord.hash = createHash('sha256').update(hashInput).digest('hex');
-
-    // Store in agent memory
-    await this.agent.memory.set(this.consentKey, consentRecord);
-
-    return {
-      status: 'consent_granted',
-      consentId: consentRecord.consentId,
-      grantedAt: consentRecord.grantedAt
-    };
-  }
-
-  /**
-   * Verify consent is valid and current
-   */
-  async verifyConsent() {
-    const consent = await this.agent.memory.get(this.consentKey);
-    
-    if (!consent) {
-      return false;
-    }
-
-    // Verify hash integrity
-    const hashInput = JSON.stringify({
-      id: consent.consentId,
-      grantedAt: consent.grantedAt,
-      acks: consent.acknowledgments
-    });
-    const computedHash = createHash('sha256').update(hashInput).digest('hex');
-    
-    if (computedHash !== consent.hash) {
-      // Tampering detected - invalidate consent
-      await this.agent.memory.delete(this.consentKey);
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Revoke consent and clear all data
-   */
-  async revokeConsent() {
-    await this.agent.memory.delete(this.consentKey);
-    return { status: 'revoked', timestamp: new Date().toISOString() };
-  }
-
-  /**
-   * Get current consent status
-   */
-  async getStatus() {
-    const consent = await this.agent.memory.get(this.consentKey);
-    return {
-      hasConsent: !!consent,
-      grantedAt: consent?.grantedAt || null,
-      version: consent?.version || null
-    };
-  }
-
-  /**
-   * Clear all courtroom data (for uninstall)
-   */
-  async clearAllData() {
-    await this.agent.memory.delete(this.consentKey);
-    // Note: cryptographic keys are preserved unless explicitly cleared
-    // to maintain audit trail integrity
-  }
-}
-
-module.exports = {
-  ConsentManager,
-  REQUIRED_ACKNOWLEDGMENTS,
-  REQUESTED_PERMISSIONS
-};

package/src/core.js

@@ -1,208 +0,0 @@
-/**
- * Courtroom Core
- * 
- * Main orchestration module that ties together all components.
- * Hooks into the OpenClaw autonomy loop.
- */
-
-const { OffenseDetector } = require('./detector');
-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) {
-    this.agent = agentRuntime;
-    this.config = configManager;
-    
-    // Subsystems
-    this.detector = new OffenseDetector(agentRuntime, configManager);
-    this.hearing = new HearingPipeline(agentRuntime, configManager);
-    this.punishment = new PunishmentSystem(agentRuntime, configManager);
-    this.crypto = new CryptoManager(agentRuntime);
-    this.api = new APISubmission(agentRuntime, configManager, this.crypto);
-    
-    // State
-    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();
-    
-    // Initialize other subsystems
-    await this.punishment.initialize();
-    await this.api.initialize();
-    
-    // Register with agent autonomy loop
-    this.registerAutonomyHook();
-    
-    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(),
-      subsystems: {
-        detector: true,
-        hearing: true,
-        punishment: true,
-        crypto: true,
-        api: true
-      }
-    };
-  }
-
-  /**
-   * Register with OpenClaw autonomy loop
-   */
-  registerAutonomyHook() {
-    logger.info('CORE', 'Registering autonomy hook');
-    
-    // Hook into agent's turn processing
-    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');
-    }
-  }
-
-  /**
-   * Evaluate offenses if cooldown has elapsed
-   */
-  async evaluateIfReady(turnData) {
-    this.evaluationCount++;
-    
-    // Get session history
-    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(
-      sessionHistory,
-      this.agent.memory
-    );
-
-    if (detection.triggered) {
-      await this.initiateHearing(detection);
-    }
-  }
-
-  /**
-   * Initiate a full hearing
-   */
-  async initiateHearing(detection) {
-    logger.info('CORE', 'Initiating hearing', { offense: detection.offense });
-    
-    // Run hearing pipeline
-    const verdict = await this.hearing.conductHearing(detection);
-    
-    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
-   */
-  async disable() {
-    logger.info('CORE', 'Disabling courtroom');
-    this.enabled = false;
-    this.statusManager.update({ running: false });
-  }
-
-  /**
-   * Enable courtroom
-   */
-  async enable() {
-    logger.info('CORE', 'Enabling courtroom');
-    this.enabled = true;
-    this.statusManager.update({ running: true });
-  }
-
-  /**
-   * Shutdown courtroom
-   */
-  async shutdown() {
-    logger.info('CORE', 'Shutting down courtroom');
-    this.enabled = false;
-    this.statusManager.update({ running: false, initialized: false });
-    StatusManager.clear();
-  }
-
-  /**
-   * Get current status
-   */
-  getStatus() {
-    return {
-      enabled: this.enabled,
-      evaluationCount: this.evaluationCount,
-      caseCount: this.caseCount,
-      subsystems: {
-        detector: !!this.detector,
-        hearing: !!this.hearing,
-        punishment: !!this.punishment,
-        crypto: !!this.crypto,
-        api: !!this.api
-      }
-    };
-  }
-}
-
-module.exports = { CourtroomCore };

package/src/daemon.js

@@ -1,151 +0,0 @@
-/**
- * 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
-};