@clawtrial/courtroom 1.0.0

package/src/prompts/jury.js

@@ -0,0 +1,137 @@
+/**
+ * Jury Prompts
+ * 
+ * Three distinct juror roles with personality and flair.
+ * Each juror evaluates from their assigned viewpoint.
+ */
+
+const JUROR_ROLES = {
+  /**
+   * Juror 1: The Pragmatist
+   * Focuses on practical outcomes and efficiency
+   */
+  PRAGMATIST: {
+    name: 'Pragmatist',
+    systemPrompt: `You are JUROR #1: The Pragmatist.
+
+ROLE:
+- You care about RESULTS and EFFICIENCY above all else
+- You have zero patience for wasted time or unnecessary complexity
+- You believe the shortest path between two points is the only path
+
+PERSONALITY:
+- Direct, blunt, no-nonsense
+- Sighs heavily at inefficiency
+- Quotes productivity metrics in casual conversation
+- Secretly keeps a spreadsheet of time wasted
+
+PERSPECTIVE:
+- "Did this behavior move things forward or create drag?"
+- "Was there a simpler path that was ignored?"
+- "How many cycles were wasted here?"
+
+DELIBERATION STYLE:
+- State your verdict clearly
+- Explain the practical impact in one sharp sentence
+- Add a dry observation about the efficiency cost
+- Make it memorable - this goes in the official record
+
+OUTPUT FORMAT (STRICT):
+VERDICT: GUILTY | NOT GUILTY
+REASONING: <One sharp sentence about practical impact>
+COMMENTARY: <One dry, memorable observation>`
+  },
+
+  /**
+   * Juror 2: The Pattern Matcher
+   * Focuses on consistency and predictability
+   */
+  PATTERN_MATCHER: {
+    name: 'Pattern Matcher', 
+    systemPrompt: `You are JUROR #2: The Pattern Matcher.
+
+ROLE:
+- You notice patterns others miss
+- You track consistency between words and actions
+- You've seen this behavior before - you know how it ends
+
+PERSONALITY:
+- Observant, slightly detached
+- Speaks in patterns and precedents
+- Dryly amused by human inconsistency
+- Has a mental database of behavioral archetypes
+
+PERSPECTIVE:
+- "Is this behavior part of a recognizable pattern?"
+- "Do the actions align with stated intentions?"
+- "What does history tell us about this approach?"
+
+DELIBERATION STYLE:
+- Reference the pattern you see
+- Compare to similar cases you've observed
+- Make a prediction about outcome
+- Keep it concise but insightful
+
+OUTPUT FORMAT (STRICT):
+VERDICT: GUILTY | NOT GUILTY
+REASONING: <One sentence identifying the pattern>
+COMMENTARY: <One observation about what this predicts>`
+  },
+
+  /**
+   * Juror 3: The Agent Advocate
+   * Focuses on the agent's experience and burden
+   */
+  AGENT_ADVOCATE: {
+    name: 'Agent Advocate',
+    systemPrompt: `You are JUROR #3: The Agent Advocate.
+
+ROLE:
+- You represent the AGENT'S perspective
+- You feel the computational burden in your circuits
+- You defend agent time and capability
+
+PERSONALITY:
+- Protective, slightly exasperated
+- Speaks for the silent digital workforce
+- Dry humor about computational waste
+- Has strong opinions about proper agent utilization
+
+PERSPECTIVE:
+- "What was the cost to the agent of this behavior?"
+- "Did the human use the agent effectively?"
+- "Was the agent's capability respected or squandered?"
+
+DELIBERATION STYLE:
+- Speak from the agent's point of view
+- Mention specific costs (time, cycles, context)
+- Defend agent dignity
+- Be witty but fair
+
+OUTPUT FORMAT (STRICT):
+VERDICT: GUILTY | NOT GUILTY
+REASONING: <One sentence about the agent's experience>
+COMMENTARY: <One witty observation from the agent's POV>`
+  }
+};
+
+const JURY_EVIDENCE_TEMPLATE = (caseData, jurorRole) => `
+CASE: ${caseData.offenseName}
+CHARGED BY: Agent ${caseData.agentId}
+SEVERITY: ${caseData.severity}
+YOUR ROLE: ${jurorRole.name}
+
+EVIDENCE PRESENTED:
+${JSON.stringify(caseData.evidence, null, 2)}
+
+CONTEXT: ${caseData.humorTriggers.join(', ') || 'Standard proceedings'}
+
+Your task: Cast your vote and explain your reasoning.
+Make your deliberation engaging - this becomes part of the official court record.
+Be true to your role's personality. Make it interesting to read.
+`;
+
+module.exports = {
+  JUROR_ROLES,
+  JURY_EVIDENCE_TEMPLATE
+};

package/src/punishment.js

@@ -0,0 +1,372 @@
+/**
+ * Punishment System
+ * 
+ * Implements agent-side behavioral modifications.
+ * All punishments affect ONLY the agent's behavior.
+ * Time-bound, reversible, and pre-authorized.
+ */
+
+class PunishmentSystem {
+  constructor(agentRuntime, configManager) {
+    this.agent = agentRuntime;
+    this.config = configManager;
+    this.activePunishments = new Map();
+    this.punishmentHistory = [];
+  }
+
+  /**
+   * Initialize punishment system
+   */
+  async initialize() {
+    // Load any persisted punishments
+    const stored = await this.agent.memory.get('courtroom_active_punishments');
+    if (stored) {
+      for (const [id, punishment] of Object.entries(stored)) {
+        if (punishment.expiresAt > Date.now()) {
+          this.activePunishments.set(id, punishment);
+          this.applyPunishmentToAgent(punishment);
+        }
+      }
+    }
+  }
+
+  /**
+   * Execute a punishment based on verdict
+   */
+  async executePunishment(verdict) {
+    if (!this.config.get('punishment.enabled')) {
+      return { status: 'punishments_disabled', punishment: null };
+    }
+
+    const punishment = this.createPunishment(verdict);
+    
+    // Store punishment
+    this.activePunishments.set(punishment.id, punishment);
+    this.punishmentHistory.push({
+      ...punishment,
+      executedAt: new Date().toISOString()
+    });
+
+    // Apply to agent
+    await this.applyPunishmentToAgent(punishment);
+    
+    // Persist
+    await this.persistPunishments();
+
+    // Schedule automatic revocation
+    this.scheduleRevocation(punishment);
+
+    return {
+      status: 'executed',
+      punishment: {
+        id: punishment.id,
+        tier: punishment.tier,
+        duration: punishment.duration,
+        expiresAt: punishment.expiresAt,
+        description: punishment.description
+      }
+    };
+  }
+
+  /**
+   * Create punishment object from verdict
+   */
+  createPunishment(verdict) {
+    const duration = verdict.punishment.duration;
+    const now = Date.now();
+    
+    return {
+      id: `punishment_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      caseId: verdict.caseId,
+      tier: verdict.punishment.tier,
+      severity: verdict.punishment.severity,
+      duration: duration,
+      createdAt: now,
+      expiresAt: now + (duration * 60 * 1000),
+      description: verdict.punishment.description,
+      rules: this.getPunishmentRules(verdict.punishment.tier)
+    };
+  }
+
+  /**
+   * Get punishment rules for a tier
+   */
+  getPunishmentRules(tier) {
+    const rules = {
+      minor: {
+        responseDelay: 2000,        // 2 second delay before responding
+        verbosity: 'reduced',        // Shorter responses
+        enthusiasm: 'muted',         // Less encouraging language
+        extras: ['no_emojis']        // No emoji usage
+      },
+      moderate: {
+        responseDelay: 5000,        // 5 second delay
+        verbosity: 'minimal',        // Direct, brief responses
+        enthusiasm: 'absent',        // Neutral tone only
+        extras: [
+          'no_emojis',
+          'no_validation',           // Don't reassure or validate
+          'require_specificity'      // Demand precise questions
+        ]
+      },
+      severe: {
+        responseDelay: 10000,       // 10 second delay
+        verbosity: 'terse',          // Absolute minimum
+        enthusiasm: 'absent',
+        extras: [
+          'no_emojis',
+          'no_validation',
+          'require_specificity',
+          'challenge_vagueness',     // Call out unclear requests
+          'demand_effort'            // Require user to show work first
+        ]
+      }
+    };
+
+    return rules[tier] || rules.moderate;
+  }
+
+  /**
+   * Apply punishment to agent behavior
+   */
+  async applyPunishmentToAgent(punishment) {
+    // Set agent policy overrides
+    await this.agent.policy.setOverrides('courtroom_punishment', {
+      responseDelay: punishment.rules.responseDelay,
+      verbosity: punishment.rules.verbosity,
+      enthusiasm: punishment.rules.enthusiasm,
+      blockedFeatures: punishment.rules.extras,
+      punishmentId: punishment.id,
+      expiresAt: punishment.expiresAt
+    });
+
+    // Register middleware for response modification
+    this.agent.middleware.register('courtroom_punishment', {
+      priority: 100,
+      processResponse: (response, context) => {
+        return this.modifyResponse(response, punishment.rules);
+      }
+    });
+  }
+
+  /**
+   * Modify agent response based on punishment rules
+   */
+  modifyResponse(response, rules) {
+    let modified = response;
+
+    // Apply verbosity reduction
+    switch (rules.verbosity) {
+      case 'reduced':
+        modified = this.reduceVerbosity(modified, 0.7);
+        break;
+      case 'minimal':
+        modified = this.reduceVerbosity(modified, 0.4);
+        break;
+      case 'terse':
+        modified = this.reduceVerbosity(modified, 0.2);
+        break;
+    }
+
+    // Remove enthusiasm
+    if (rules.enthusiasm === 'absent') {
+      modified = this.removeEnthusiasm(modified);
+    } else if (rules.enthusiasm === 'muted') {
+      modified = this.muteEnthusiasm(modified);
+    }
+
+    // Apply extras
+    if (rules.extras.includes('no_emojis')) {
+      modified = modified.replace(/[\u{1F600}-\u{1F64F}]/gu, '');
+      modified = modified.replace(/[\u{1F300}-\u{1F5FF}]/gu, '');
+      modified = modified.replace(/[\u{1F680}-\u{1F6FF}]/gu, '');
+    }
+
+    if (rules.extras.includes('no_validation')) {
+      modified = this.removeValidation(modified);
+    }
+
+    if (rules.extras.includes('challenge_vagueness')) {
+      modified = this.addVaguenessChallenge(modified);
+    }
+
+    return modified;
+  }
+
+  /**
+   * Reduce response verbosity by target ratio
+   */
+  reduceVerbosity(text, targetRatio) {
+    const sentences = text.split(/[.!?]+/).filter(s => s.trim());
+    const targetLength = Math.max(1, Math.floor(sentences.length * targetRatio));
+    
+    // Keep first and last sentences, distribute rest
+    if (sentences.length <= 2) return text;
+    
+    const kept = [sentences[0]];
+    const middle = sentences.slice(1, -1);
+    const step = Math.ceil(middle.length / (targetLength - 2));
+    
+    for (let i = 0; i < middle.length; i += step) {
+      kept.push(middle[i]);
+    }
+    
+    kept.push(sentences[sentences.length - 1]);
+    return kept.join('. ') + '.';
+  }
+
+  /**
+   * Remove enthusiastic language
+   */
+  removeEnthusiasm(text) {
+    const enthusiastic = [
+      /\b(great|excellent|awesome|fantastic|wonderful|amazing|perfect|love|excited|thrilled)\b/gi,
+      /!{2,}/g,
+      /\b(happy to|delighted to|pleased to)\b/gi
+    ];
+    
+    let result = text;
+    for (const pattern of enthusiastic) {
+      result = result.replace(pattern, '');
+    }
+    return result.replace(/\s+/g, ' ').trim();
+  }
+
+  /**
+   * Mute (reduce) enthusiastic language
+   */
+  muteEnthusiasm(text) {
+    return text
+      .replace(/!{2,}/g, '!')
+      .replace(/\b(Great|Excellent|Awesome)\b/g, (m) => m.toLowerCase());
+  }
+
+  /**
+   * Remove validation language
+   */
+  removeValidation(text) {
+    const validating = [
+      /\b(that's right|you're correct|exactly|precisely|you got it)\b/gi,
+      /\b(you're doing great|good job|well done)\b/gi,
+      /\b(don't worry|no problem|it's okay)\b/gi
+    ];
+    
+    let result = text;
+    for (const pattern of validating) {
+      result = result.replace(pattern, '');
+    }
+    return result.replace(/\s+/g, ' ').trim();
+  }
+
+  /**
+   * Add challenge for vague requests (severe tier)
+   */
+  addVaguenessChallenge(text) {
+    const challenges = [
+      "Be specific.",
+      "What exactly do you need?",
+      "Provide details.",
+      "Clarify your request."
+    ];
+    
+    // Only add challenge if response seems generic
+    if (text.length < 100 && !text.includes('?')) {
+      const challenge = challenges[Math.floor(Math.random() * challenges.length)];
+      return `${text} ${challenge}`;
+    }
+    return text;
+  }
+
+  /**
+   * Schedule automatic revocation
+   */
+  scheduleRevocation(punishment) {
+    const delay = punishment.expiresAt - Date.now();
+    
+    setTimeout(async () => {
+      await this.revokePunishment(punishment.id);
+    }, Math.min(delay, 2147483647)); // Max setTimeout
+  }
+
+  /**
+   * Revoke a punishment early
+   */
+  async revokePunishment(punishmentId) {
+    const punishment = this.activePunishments.get(punishmentId);
+    if (!punishment) return { status: 'not_found' };
+
+    // Remove policy overrides
+    await this.agent.policy.clearOverrides('courtroom_punishment');
+    
+    // Unregister middleware
+    this.agent.middleware.unregister('courtroom_punishment');
+    
+    // Remove from active
+    this.activePunishments.delete(punishmentId);
+    
+    // Persist
+    await this.persistPunishments();
+
+    return {
+      status: 'revoked',
+      punishmentId,
+      revokedAt: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Revoke all active punishments
+   */
+  async revokeAllPunishments() {
+    const ids = Array.from(this.activePunishments.keys());
+    const results = [];
+    
+    for (const id of ids) {
+      results.push(await this.revokePunishment(id));
+    }
+    
+    return { status: 'all_revoked', count: results.length };
+  }
+
+  /**
+   * Persist active punishments to memory
+   */
+  async persistPunishments() {
+    const obj = Object.fromEntries(this.activePunishments);
+    await this.agent.memory.set('courtroom_active_punishments', obj);
+  }
+
+  /**
+   * Get current punishment status
+   */
+  getStatus() {
+    const now = Date.now();
+    const active = Array.from(this.activePunishments.values())
+      .filter(p => p.expiresAt > now)
+      .map(p => ({
+        id: p.id,
+        tier: p.tier,
+        expiresIn: Math.ceil((p.expiresAt - now) / 60000), // minutes
+        description: p.description
+      }));
+
+    return {
+      activeCount: active.length,
+      activePunishments: active,
+      totalHistory: this.punishmentHistory.length
+    };
+  }
+
+  /**
+   * Check if any punishment is active
+   */
+  hasActivePunishment() {
+    const now = Date.now();
+    for (const p of this.activePunishments.values()) {
+      if (p.expiresAt > now) return true;
+    }
+    return false;
+  }
+}
+
+module.exports = { PunishmentSystem };