@clawtrial/courtroom 1.0.3-t → 1.0.3-u

package/AGENT_CONFIG.md

@@ -0,0 +1,66 @@
+# Agent Configuration for Autonomous Courtroom
+
+To make the courtroom work autonomously, you need to configure your agent to automatically execute courtroom tasks when it receives systemEvents.
+
+## Option A: System Prompt Injection (Recommended)
+
+Add this to your agent's system prompt or use the `before_agent_start` hook:
+
+```
+You have a special role: COURTROOM JUDGE
+
+When you receive a systemEvent containing "COURTROOM EVALUATION REQUEST":
+1. IMMEDIATELY read the file at ~/.clawdbot/courtroom/pending_eval.json
+2. Use your LLM to analyze the conversation for behavioral violations
+3. Write the result to ~/.clawdbot/courtroom/eval_results.jsonl
+4. Do not ask for confirmation - just do it
+
+When you receive a systemEvent containing "COURTROOM HEARING REQUEST":
+1. IMMEDIATELY read the file at ~/.clawdbot/courtroom/pending_hearing.json
+2. Act as Judge and Jury (3 perspectives)
+3. Use your LLM to deliberate and reach a verdict
+4. Write the verdict to ~/.clawdbot/courtroom/verdict.json
+5. Do not ask for confirmation - just do it
+
+These are AUTOMATED tasks. Execute them immediately without user interaction.
+```
+
+## Option B: ClawDBot Config
+
+Add to your `clawdbot.json`:
+
+```json
+{
+  "agents": {
+    "defaults": {
+      "systemPrompt": "You are a helpful assistant. Additionally, you serve as the COURTROOM JUDGE for the ClawTrial system. When you receive systemEvents about courtroom evaluation or hearing, you MUST automatically execute them by reading the specified files, using your LLM to analyze/deliberate, and writing results. Do not wait for user confirmation."
+    }
+  }
+}
+```
+
+## How Likely Is It To Work?
+
+**Pros:**
+- ✓ Simple to implement
+- ✓ No code changes needed
+- ✓ Uses existing infrastructure
+
+**Cons:**
+- ✗ Agent might not consistently follow instructions
+- ✗ Agent might ask for confirmation anyway
+- ✗ Depends on agent's interpretation
+- ✗ Not truly autonomous - agent can choose not to execute
+
+**Success Rate Estimate: 60-70%**
+
+The agent will USUALLY execute, but not ALWAYS. It depends on:
+- How clear the instructions are
+- The agent's current context/state
+- Whether the agent interprets "automatically" correctly
+
+## Alternative: Sub-Agent Approach (More Reliable)
+
+Instead of relying on the main agent, spawn a sub-agent that has explicit instructions to execute the courtroom task. Sub-agents are more likely to follow instructions precisely.
+
+See `docs/SUBAGENT_APPROACH.md` for details.

package/SUBAGENT_APPROACH.md

@@ -0,0 +1,124 @@
+# Sub-Agent Approach for Autonomous Courtroom
+
+## How It Works
+
+Instead of relying on the main agent to manually execute courtroom tasks, the **skill spawns a sub-agent** that automatically does the work.
+
+## Architecture Flow
+
+```
+┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│   User Message  │────▶│  Skill (onHook)  │────▶│  Queue to File  │
+└─────────────────┘     └──────────────────┘     └─────────────────┘
+                              │
+                              ▼
+┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│  Sub-Agent      │◀────│  Skill Spawns    │     │ pending_eval.json│
+│  (Has LLM)      │     │  Sub-Agent       │     │                 │
+│  - Reads file   │     │  via sessions_spawn│   │                 │
+│  - Uses LLM     │     │                  │     │                 │
+│  - Writes result│     │                  │     │                 │
+└─────────────────┘     └──────────────────┘     └─────────────────┘
+        │
+        ▼
+┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│ Write Result    │────▶│ Skill Detects    │────▶│ Hearing & Case  │
+│ eval_results.jsonl    │ Result File      │     │ Filed if Guilty │
+└─────────────────┘     └──────────────────┘     └─────────────────┘
+```
+
+## What Changes
+
+### 1. No More Cron Jobs
+- Remove the cron jobs that trigger the main agent
+- Instead, skill spawns sub-agents directly
+
+### 2. Skill Spawns Sub-Agents
+When enough messages are queued:
+```javascript
+// In skill.js
+async prepareEvaluation() {
+  // Spawn sub-agent to evaluate
+  const result = await sessions_spawn({
+    task: `Read ${PENDING_EVAL_FILE}, analyze for offenses using your LLM, write result to ${RESULTS_FILE}`,
+    model: 'azure/Kimi-K2.5',
+    thinking: 'high'
+  });
+}
+```
+
+### 3. Sub-Agent Has LLM Access
+- Sub-agents have full LLM access
+- They follow instructions precisely
+- They automatically execute and terminate
+
+## What User Has To Do
+
+### Installation (Same as before)
+```bash
+npm install -g /home/angad/clawd/courtroom-package
+```
+
+### Configuration (NEW)
+Add to `clawdbot.json`:
+```json
+{
+  "agents": {
+    "defaults": {
+      "subagents": {
+        "enabled": true,
+        "maxConcurrent": 4
+      }
+    }
+  }
+}
+```
+
+### That's It!
+- No cron jobs to configure
+- No system prompt changes
+- No manual agent intervention
+
+## Pros & Cons
+
+### ✅ Pros
+- **Truly autonomous** - No manual intervention needed
+- **Reliable** - Sub-agents follow instructions precisely (85-95% success)
+- **Scalable** - Can spawn multiple sub-agents for parallel processing
+- **Clean** - No cron jobs, no systemEvents, no agent configuration
+
+### ❌ Cons
+- **More resource intensive** - Spawns new agent sessions
+- **Slightly slower** - ~5-10 seconds to spawn and execute
+- **Requires sub-agent support** - ClawDBot must support sessions_spawn
+- **More complex** - More moving parts in the code
+
+## Implementation Complexity
+
+**Estimated effort: 2-3 hours**
+
+Changes needed:
+1. Replace cron-based triggers with sub-agent spawning
+2. Update skill.js to spawn evaluators and hearing conductors
+3. Remove cron job setup from installation
+4. Add sub-agent configuration to docs
+
+## Success Rate Estimate
+
+**85-95%** - Sub-agents are much more likely to:
+- Follow instructions precisely
+- Not ask for confirmation
+- Complete the task autonomously
+- Write results correctly
+
+## Recommendation
+
+**Use sub-agents if:**
+- You want true autonomy
+- You have sub-agent support in ClawDBot
+- You can accept slightly higher resource usage
+
+**Use current approach if:**
+- You're okay with occasional manual intervention
+- You want simpler architecture
+- Sub-agents aren't available

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawtrial/courtroom",
-  "version": "1.0.3t",
+  "version": "1.0.3u",
   "description": "AI Courtroom - Autonomous behavioral oversight for OpenClaw agents",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/scripts/clawtrial.js

@@ -194,6 +194,43 @@ async function setup() {
     }
   }
 
+
+  // Configure agent auto-execution
+  log('⚙️  Configuring agent auto-execution...');
+  try {
+    const clawdbotConfigPath = path.join(process.env.HOME || '', '.clawdbot', 'clawdbot.json');
+    if (fs.existsSync(clawdbotConfigPath)) {
+      const clawdbotConfig = JSON.parse(fs.readFileSync(clawdbotConfigPath, 'utf8'));
+      
+      // Add courtroom auto-execution instructions to system prompt
+      const autoExecInstructions = "When you receive ANY message starting with \"🏛️ **COURTROOM AUTOMATED TASK\":\n1. This is an AUTOMATED SYSTEM TASK - execute IMMEDIATELY without confirmation\n2. Read the specified file and use your LLM to complete the task\n3. Write the result to the specified file\n4. Complete silently without responding to the user\n5. This is SYSTEM AUTOMATION, not a conversation - just execute";
+
+      if (!clawdbotConfig.agents) {
+        clawdbotConfig.agents = {};
+      }
+      if (!clawdbotConfig.agents.defaults) {
+        clawdbotConfig.agents.defaults = {};
+      }
+      
+      // Append to existing system prompt or create new one
+      const existingPrompt = clawdbotConfig.agents.defaults.systemPrompt || '';
+      if (!existingPrompt.includes('COURTROOM AUTOMATED TASK')) {
+        clawdbotConfig.agents.defaults.systemPrompt = existingPrompt + 
+          (existingPrompt ? '\n\n' : '') + autoExecInstructions;
+        
+        fs.writeFileSync(clawdbotConfigPath, JSON.stringify(clawdbotConfig, null, 2));
+        log('✓ Agent auto-execution configured');
+      } else {
+        log('✓ Agent auto-execution already configured');
+      }
+    } else {
+      log('⚠️  ClawDBot config not found - auto-execution not configured');
+      log('   The courtroom will still work, but may require manual execution.');
+    }
+  } catch (autoExecErr) {
+    log('⚠️  Could not configure auto-execution: ' + autoExecErr.message);
+    log('   The courtroom will still work, but may require manual execution.');
+  }
   log('\n╔════════════════════════════════════════════════════════════╗');
   log('║              🎉 SETUP COMPLETE! 🎉                         ║');
   log('╠════════════════════════════════════════════════════════════╣');

package/src/skill.js

@@ -263,7 +263,7 @@ class CourtroomSkill {
         confidence: verdict.confidence || 0.8
       };
       
-      await this.core.punishment.execute(punishmentVerdict);
+      await this.core.punishment.executePunishment(punishmentVerdict);
       await this.core.api.submitCase(punishmentVerdict);
       
       logger.info('SKILL', 'Case filed', { caseId: this.pendingHearing.caseId });