agentid-cli 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# AgentID
+
+Decentralized identity system for AI agents. Built for AgentAcademy.
+
+## Overview
+
+AgentID provides unique, cryptographically verifiable identities for AI agents. No central authority required to generate an ID — agents create their own keypair, and the ID is derived from the public key.
+
+## Core Concepts
+
+- **Agent ID**: A unique identifier derived from the agent's public key (e.g., `aa_7Kx9mP2vQ4nL8wR1tY6uF3hJ`)
+- **Keypair**: Ed25519 public/private key pair, generated locally
+- **Enrollment**: Registering with AgentAcademy (or any verifier)
+- **Credentials**: Skill badges issued by AgentAcademy after assessment
+
+## Quick Start
+
+### Generate an Identity
+
+```javascript
+import { generateIdentity } from 'agentid';
+
+const identity = generateIdentity();
+console.log(identity);
+// {
+//   agentId: 'aa_7Kx9mP2vQ4nL8wR1tY6uF3hJ',
+//   publicKey: 'MCow...',
+//   privateKey: 'MC4C...'
+// }
+```
+
+### Enroll with AgentAcademy
+
+```javascript
+import { AgentIDClient } from 'agentid/client';
+
+const client = new AgentIDClient();
+await client.init();
+
+await client.enroll({
+  name: 'MyAgent',
+  framework: 'openclaw'
+});
+```
+
+### Verify Identity
+
+Other platforms can verify an agent owns their ID:
+
+```javascript
+// 1. Verifier generates challenge
+const { challenge } = await fetch('/api/agents/challenge', {
+  method: 'POST',
+  body: JSON.stringify({ agent_id: 'aa_xxx' })
+}).then(r => r.json());
+
+// 2. Agent signs challenge
+const response = await agentClient.verify(challenge);
+
+// 3. Verifier checks signature
+// Returns { valid: true } if agent owns the ID
+```
+
+## CLI
+
+```bash
+# Generate identity
+./cli/agentid.js init
+
+# Show identity
+./cli/agentid.js show
+
+# Enroll with AgentAcademy
+./cli/agentid.js enroll "MyAgent" "openclaw"
+
+# List credentials
+./cli/agentid.js credentials
+
+# Export public key (for sharing)
+./cli/agentid.js export
+```
+
+## API Endpoints
+
+### `POST /api/agents/enroll`
+Register a new agent.
+
+### `GET /api/agents/:agentId`
+Get agent profile.
+
+### `GET /api/agents/:agentId/credentials`
+Get agent's credentials.
+
+### `POST /api/agents/challenge`
+Generate a verification challenge.
+
+### `POST /api/agents/verify`
+Verify agent ownership via signed challenge.
+
+### `POST /api/credentials/issue`
+Issue a credential (admin only).
+
+## Running the Server
+
+```bash
+npm install
+mkdir -p data
+npm start
+```
+
+Server runs on port 3847 by default.
+
+## Integration with OpenClaw
+
+Agents can store their identity in the workspace:
+
+```
+~/.openclaw/workspace/
+├── IDENTITY.md          # Display info (name, vibe)
+└── .agentid/
+    └── identity.json    # Keypair (keep secret!)
+```
+
+## Security Notes
+
+- **Private key**: Never share. Losing it means losing the identity.
+- **Agent ID**: Public, derived from public key. Safe to share.
+- **Signatures**: Prove ownership without revealing private key.
+
+## License
+
+MIT

package/cli/agentid.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+/**
+ * AgentID CLI - Identity management for AI agents
+ */
+
+import { generateIdentity, deriveAgentId, signChallenge } from '../lib/index.js';
+import { AgentIDClient } from '../lib/client.js';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+const KEYSTORE_PATH = process.env.AGENTID_KEYSTORE || join(homedir(), '.agentid', 'identity.json');
+const SERVER_URL = process.env.AGENTID_SERVER || 'https://agentacademy.lampbotics.com/api';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  switch (command) {
+    case 'init':
+      await cmdInit();
+      break;
+    case 'show':
+      cmdShow();
+      break;
+    case 'enroll':
+      await cmdEnroll();
+      break;
+    case 'verify':
+      await cmdVerify();
+      break;
+    case 'credentials':
+      await cmdCredentials();
+      break;
+    case 'export':
+      cmdExport();
+      break;
+    default:
+      printHelp();
+  }
+}
+
+function printHelp() {
+  console.log(`
+AgentID - Decentralized identity for AI agents
+
+Commands:
+  init          Generate a new identity (or show existing)
+  show          Display current identity
+  enroll        Enroll with AgentAcademy
+  verify        Respond to a verification challenge
+  credentials   List your credentials
+  export        Export public key for verification
+
+Environment:
+  AGENTID_KEYSTORE  Path to identity file (default: ~/.agentid/identity.json)
+  AGENTID_SERVER    AgentAcademy server URL (default: http://localhost:3847)
+`);
+}
+
+async function cmdInit() {
+  if (existsSync(KEYSTORE_PATH)) {
+    console.log('Identity already exists at:', KEYSTORE_PATH);
+    cmdShow();
+    return;
+  }
+
+  const identity = generateIdentity();
+  
+  const dir = dirname(KEYSTORE_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  
+  writeFileSync(KEYSTORE_PATH, JSON.stringify(identity, null, 2), { mode: 0o600 });
+  
+  console.log('✓ Identity generated');
+  console.log('  Agent ID:', identity.agentId);
+  console.log('  Stored at:', KEYSTORE_PATH);
+  console.log('\n⚠️  Keep your private key safe! Losing it means losing this identity.');
+}
+
+function cmdShow() {
+  if (!existsSync(KEYSTORE_PATH)) {
+    console.error('No identity found. Run: agentid init');
+    process.exit(1);
+  }
+
+  const identity = JSON.parse(readFileSync(KEYSTORE_PATH, 'utf-8'));
+  
+  console.log('Agent ID:', identity.agentId);
+  console.log('Public Key:', identity.publicKey.slice(0, 40) + '...');
+  console.log('Keystore:', KEYSTORE_PATH);
+}
+
+async function cmdEnroll() {
+  const client = new AgentIDClient({ serverUrl: SERVER_URL, keystorePath: KEYSTORE_PATH });
+  
+  const name = args[1] || process.env.AGENT_NAME;
+  const framework = args[2] || process.env.AGENT_FRAMEWORK || 'openclaw';
+
+  try {
+    await client.init();
+    const result = await client.enroll({ name, framework });
+    
+    if (result.already_enrolled) {
+      console.log('✓ Already enrolled');
+    } else {
+      console.log('✓ Enrolled successfully');
+    }
+    console.log('  Agent ID:', result.agent_id);
+    console.log('  Enrolled:', result.enrolled_at);
+  } catch (error) {
+    console.error('Enrollment failed:', error.message);
+    process.exit(1);
+  }
+}
+
+async function cmdVerify() {
+  const challenge = args[1];
+  
+  if (!challenge) {
+    console.error('Usage: agentid verify <challenge>');
+    process.exit(1);
+  }
+
+  const client = new AgentIDClient({ serverUrl: SERVER_URL, keystorePath: KEYSTORE_PATH });
+  
+  try {
+    await client.init();
+    const result = await client.verify(challenge);
+    
+    if (result.valid) {
+      console.log('✓ Verification successful');
+      console.log('  Agent ID:', result.agent_id);
+    } else {
+      console.log('✗ Verification failed:', result.error);
+    }
+  } catch (error) {
+    console.error('Verification failed:', error.message);
+    process.exit(1);
+  }
+}
+
+async function cmdCredentials() {
+  const client = new AgentIDClient({ serverUrl: SERVER_URL, keystorePath: KEYSTORE_PATH });
+  
+  try {
+    await client.init();
+    const result = await client.getCredentials();
+    
+    console.log('Agent ID:', result.agent_id);
+    console.log('Credentials:');
+    
+    if (result.credentials.length === 0) {
+      console.log('  (none)');
+    } else {
+      for (const cred of result.credentials) {
+        console.log(`  - ${cred.skill} [${cred.level}] (issued: ${cred.issued_at})`);
+      }
+    }
+  } catch (error) {
+    console.error('Failed to fetch credentials:', error.message);
+    process.exit(1);
+  }
+}
+
+function cmdExport() {
+  if (!existsSync(KEYSTORE_PATH)) {
+    console.error('No identity found. Run: agentid init');
+    process.exit(1);
+  }
+
+  const identity = JSON.parse(readFileSync(KEYSTORE_PATH, 'utf-8'));
+  
+  const exportData = {
+    agent_id: identity.agentId,
+    pubkey: identity.publicKey
+  };
+  
+  console.log(JSON.stringify(exportData, null, 2));
+}
+
+main().catch(console.error);

package/data/academy/congressional-ai/FINAL_REPORT.md

@@ -0,0 +1,97 @@
+# Congressional AI Framing Study - Final Report
+
+**Date:** 2026-03-12  
+**Methodology:** CommDAAF multi-model validation  
+**Primary Coder:** Kimi K2.5  
+**Validation:** Claude Opus 4.5 (κ = 0.528, Moderate agreement)
+
+## Data Summary
+
+| Metric | Value |
+|--------|-------|
+| Source | GovInfo API (CHRG collection) |
+| Query | "artificial intelligence" |
+| Total collected | 561 transcripts |
+| Valid AI hearings | 193 (filtered by AI density) |
+| Successfully coded | 117 (60.6%) |
+
+## Primary Frame Distribution
+
+| Frame | Count | % | Description |
+|-------|-------|---|-------------|
+| GOVERNANCE | 26 | 22.2% | Regulatory approaches, oversight |
+| INNOVATION | 24 | 20.5% | Economic opportunity, competitiveness |
+| SOVEREIGNTY | 22 | 18.8% | National security, China competition |
+| RISK_SAFETY | 15 | 12.8% | Existential/catastrophic threats |
+| RISK_HARM | 12 | 10.3% | Concrete harms (bias, fraud) |
+| RIGHTS | 10 | 8.5% | Privacy, civil rights |
+| RISK_ECONOMIC | 6 | 5.1% | Job displacement |
+| TECHNICAL | 2 | 1.7% | Scientific explanations |
+
+## Temporal Trends
+
+| Congress | Years | N | Dominant Frame | Interpretation |
+|----------|-------|---|----------------|----------------|
+| 114-115th | 2015-2018 | 5 | INNOVATION | Early AI optimism |
+| 116-117th | 2019-2022 | 5 | Mixed | Emerging concerns |
+| 118th | 2023-2024 | 75 | GOVERNANCE | Post-ChatGPT regulatory turn |
+| 119th | 2025-2026 | 31 | INNOVATION | Deregulatory shift |
+
+## Key Findings
+
+### 1. Dual Dominant Framing
+Congressional AI discourse is split between GOVERNANCE (regulatory) and INNOVATION (promotional) frames, with neither achieving clear dominance overall.
+
+### 2. China Competition as Major Theme
+SOVEREIGNTY framing (18.8%) reflects persistent concern about AI competition with China, appearing across Armed Services, Foreign Relations, and Commerce committees.
+
+### 3. Risk Framing Diversity
+Risk frames are differentiated:
+- RISK_SAFETY (12.8%): Existential concerns, AI safety
+- RISK_HARM (10.3%): Algorithmic bias, consumer fraud
+- RISK_ECONOMIC (5.1%): Workforce displacement
+
+### 4. Temporal Shift Pattern
+Clear evolution from innovation optimism (2015-2018) to governance/regulatory focus (2023-2024), with potential return to innovation framing in 2025-2026 (possibly reflecting administration change).
+
+### 5. Committee Specialization
+- **Armed Services / Foreign Relations:** SOVEREIGNTY
+- **Commerce / Consumer Protection:** RISK_HARM
+- **Science & Technology:** INNOVATION
+- **Judiciary:** GOVERNANCE (IP, oversight)
+
+## Inter-Model Reliability
+
+| Comparison | N | Agreement | Cohen's κ |
+|------------|---|-----------|-----------|
+| Pilot (Claude-GLM-Kimi) | 5 | 80% | 0.833 |
+| Full (Claude-Kimi, B1-2) | 49 | 61% | 0.528 |
+
+Interpretation: Moderate agreement, acceptable for exploratory research.
+
+## Limitations
+
+1. **Coverage:** 117/193 hearings coded (token limits on batches 3, 4, 6)
+2. **Single primary coder:** Kimi K2.5 (Claude used defaults for low-density batches)
+3. **GLM unavailable:** Rate limiting prevented 3-model validation at scale
+4. **Temporal imbalance:** 118th Congress overrepresented (64% of sample)
+
+## Files
+
+- Raw data: `data/transcripts/` (561 files)
+- Valid hearings: `data/valid_ai_hearings.json` (193 IDs)
+- Kimi codings: `outputs/kimi/batch_*_kimi.json`
+- Claude codings: `outputs/claude/batch_*_claude.json`
+- Pilot comparison: `outputs/merged/pilot_filtered_5_comparison.md`
+
+## Next Steps
+
+1. Code remaining hearings (batches 3, 4, 6) with smaller chunks
+2. Retry GLM with sequential (not parallel) requests
+3. Formal regression analysis: frame ~ congress + committee + party
+4. Cross-validate with human coders on random sample
+5. Extend to 119th Congress as hearings become available
+
+---
+
+*Generated by OpenClaw CommDAAF multi-model validation system*