@weave_protocol/domere

⚖️ Dōmere - Judge Protocol

Enterprise-grade verification, orchestration, compliance, and audit infrastructure for AI agents.

Part of the Weave Protocol Security Suite.

✨ Features

Category	Features
Verification	Intent tracking, drift detection, execution replay, multi-agent handoff
Orchestration	Task scheduler, agent registry, shared state with locks
Compliance	SOC2, HIPAA, PCI-DSS, ISO27001 checkpoints & reporting
Blockchain	Solana & Ethereum anchoring for immutable audit trails

📦 Installation

npm install @weave_protocol/domere

🚀 Quick Start: Multi-Agent Orchestration

import { Orchestrator } from '@weave_protocol/domere';

// Configure agent limit as needed (no hard maximum)
const orch = new Orchestrator({ max_agents: 10 });
await orch.start();

// Register agents
for (let i = 0; i < 10; i++) {
  await orch.registerAgent({
    name: `agent-${i}`,
    capabilities: ['research', 'analysis', 'coding'][i % 3],
    max_concurrent_tasks: 3
  });
}

// Submit tasks with dependencies
const task1 = await orch.submitTask({
  intent: 'Fetch Q3 data',
  priority: 'high'
});

const task2 = await orch.submitTask({
  intent: 'Analyze Q3 trends',
  dependencies: [task1.id]  // Waits for task1
});

// Get stats
const stats = orch.getStats();
console.log(`${stats.agents.ready} agents ready, ${stats.tasks.queued} tasks queued`);

📊 Task Scheduler

Priority queue with dependencies, retries, and load balancing.

import { TaskScheduler } from '@weave_protocol/domere';

const scheduler = new TaskScheduler();

const task = await scheduler.createTask({
  intent: 'Analyze Q3 data',
  priority: 'high',
  dependencies: ['fetch-data-task'],
  constraints: {
    required_capabilities: ['data-analysis'],
    max_duration_ms: 300000,
    exclusive_resources: ['gpu-1']
  },
  retry_policy: {
    max_retries: 3,
    backoff: 'exponential'
  }
});

// Auto-assign to best agent
const assignment = await scheduler.assignTask(task.id);

// Track progress
scheduler.onTaskProgress(task.id, (p) => console.log(`${p.percent}%`));

// Handle completion
scheduler.onTaskComplete(task.id, (result) => {
  console.log(`Completed in ${result.duration_ms}ms`);
});

🤖 Agent Registry

Agent lifecycle, heartbeat monitoring, and failover.

import { AgentRegistry } from '@weave_protocol/domere';

const registry = new AgentRegistry({
  heartbeat_interval_ms: 5000,
  heartbeat_timeout_ms: 15000
});

// Register agent
const agent = await registry.register({
  agent_id: 'agent-7',
  capabilities: ['code-generation', 'testing'],
  max_concurrent_tasks: 3
});

await registry.setReady('agent-7');

// Process heartbeats
await registry.heartbeat({
  agent_id: 'agent-7',
  current_tasks: ['task_1', 'task_2']
});

// Handle failures
registry.onAgentDown((agent, tasks) => {
  console.log(`${agent.id} down with ${tasks.length} tasks`);
  // Reassign tasks...
});

// Find best agent
const best = registry.getBestAgent({
  capabilities: ['code-generation'],
  prefer_lowest_load: true
});

🗃️ State Manager

Shared state with locking, branching, and conflict resolution.

import { StateManager } from '@weave_protocol/domere';

const state = new StateManager({
  conflict_resolution: 'last-write-wins'
});

// Lock before writing
const lock = await state.acquireLock({
  key: 'customer-db',
  holder: 'agent-3',
  duration_ms: 30000,
  type: 'exclusive'
});

if (lock.acquired) {
  await state.set('customer-db', { updated: true });
  await state.releaseLock('customer-db', 'agent-3');
}

// Git-style branching
await state.createBranch('experiment', { parent: 'main' });
await state.set('config', newConfig, { branch: 'experiment' });

// Merge with conflict detection
const result = await state.merge('experiment', 'main');
if (result.conflicts.length > 0) {
  // Resolve conflicts
}

// Snapshots for rollback
const snap = await state.createSnapshot();
// ... later ...
await state.restoreSnapshot(snap.id);

🔄 Execution Replay

Tamper-proof audit trail with cryptographic verification.

import { ExecutionReplayManager } from '@weave_protocol/domere';

const replay = new ExecutionReplayManager('encryption-key');

// Record actions
await replay.recordAction({
  thread_id: 'thr_xxx',
  agent_id: 'gpt-4-agent',
  agent_type: 'llm',
  action_type: 'inference',
  action_name: 'generate_report',
  input: { prompt: '...' },
  output: { response: '...' },
  latency_ms: 1250,
  cost_usd: 0.03,
  tokens_in: 500,
  tokens_out: 1000
});

// Get trail
const trail = await replay.getExecutionTrail('thr_xxx');
console.log(trail.integrity_valid);  // true
console.log(trail.merkle_root);      // For blockchain

// Generate report
const report = await replay.generateAuditReport({
  start_time: new Date('2026-01-01'),
  end_time: new Date('2026-01-31')
});

🤝 Multi-Agent Handoff

Secure delegation with permission inheritance.

import { HandoffManager } from '@weave_protocol/domere';

const handoff = new HandoffManager('signing-key', {
  max_delegation_depth: 5
});

// Create handoff token
const token = await handoff.createHandoff({
  thread_id: 'thr_xxx',
  from_agent: 'orchestrator',
  to_agent: 'researcher',
  delegated_intent: 'Find Q3 data',
  constraints: ['read-only'],
  permissions: [{ resource: 'database', actions: ['read'] }],
  max_actions: 10,
  expires_in_ms: 300000
});

// Verify before acting
const v = await handoff.verifyHandoff(token.token, 'researcher');
if (v.valid) {
  console.log(`${v.remaining_actions} actions left`);
}

// Track chain
const chain = await handoff.getDelegationChain('thr_xxx');
console.log(`Depth: ${chain.depth}, Valid: ${chain.integrity_valid}`);

📋 Compliance (SOC2/HIPAA/PCI-DSS/ISO27001)

Automated compliance tracking and reporting for multiple frameworks.

import { ComplianceManager } from '@weave_protocol/domere';

const compliance = new ComplianceManager('signing-key');

// HIPAA: Log PHI access
await compliance.logPHIAccess({
  thread_id: 'thr_xxx',
  agent_id: 'medical-ai',
  patient_id: 'patient_123',
  access_reason: 'Treatment',
  data_accessed: ['diagnosis'],
  legal_basis: 'treatment'
});

// SOC2: Log access control
await compliance.logAccessControl({
  thread_id: 'thr_xxx',
  agent_id: 'admin-bot',
  resource: 'reports',
  action: 'grant',
  success: true
});

// PCI-DSS: Log cardholder data access
await compliance.logCardholderDataAccess({
  thread_id: 'thr_xxx',
  agent_id: 'payment-processor',
  data_type: 'pan',
  action: 'access',
  masked: true,
  encrypted: true,
  business_justification: 'Process refund'
});

// ISO27001: Log security incident
await compliance.logSecurityIncident({
  thread_id: 'thr_xxx',
  agent_id: 'security-monitor',
  incident_id: 'INC-001',
  incident_type: 'unauthorized_access',
  severity: 'high',
  status: 'investigating',
  affected_assets: ['db-prod-1'],
  description: 'Unusual access pattern detected'
});

// ISO27001: Log asset management
await compliance.logAssetEvent({
  thread_id: 'thr_xxx',
  agent_id: 'asset-manager',
  asset_id: 'srv-prod-5',
  asset_type: 'hardware',
  action: 'classify',
  classification: 'confidential'
});

// Generate report
const report = await compliance.generateReport({
  framework: 'PCI-DSS',
  period_start: new Date('2026-01-01'),
  period_end: new Date('2026-03-31')
});
console.log(`Score: ${report.compliance_score}`);

⛓️ Blockchain Anchoring

Immutable proof on Solana and Ethereum.

import { EthereumAnchor } from '@weave_protocol/domere';

const anchor = new EthereumAnchor({
  contract_address: '0xAA8b52adD3CEce6269d14C6335a79df451543820'
});

await anchor.anchorThread({
  thread_id: 'thr_xxx',
  merkle_root: trail.merkle_root,
  intent_hash: 'abc123...',
  compliant: true
});

Chain	Network	Address
Solana	Mainnet	6g7raTAHU2h331VKtfVtkS5pmuvR8vMYwjGsZF1CUj2o
Solana	Devnet	BeCYVJYfbUu3k2TPGmh9VoGWeJwzm2hg2NdtnvbdBNCj
Ethereum	Mainnet	0xAA8b52adD3CEce6269d14C6335a79df451543820

📚 API Reference

Orchestrator

Method	Description
start()	Start orchestrator
registerAgent(params)	Register new agent
submitTask(params)	Submit task to queue
heartbeat(agentId, tasks)	Process agent heartbeat
taskCompleted(agentId, taskId, result)	Report completion
getStats()	Get orchestrator stats

TaskScheduler

Method	Description
createTask(params)	Create task with dependencies
assignTask(taskId, agentId?)	Assign to agent
completeTask(taskId, agentId, result)	Mark complete
failTask(taskId, agentId, error)	Mark failed (auto-retry)
reassignFromAgent(agentId)	Reassign failed agent's tasks

AgentRegistry

Method	Description
register(params)	Register agent
heartbeat(payload)	Process heartbeat
findAgents(query)	Find matching agents
drain(agentId)	Stop accepting tasks
deregister(agentId)	Remove agent

StateManager

Method	Description
get(key) / set(key, value)	Basic operations
acquireLock(request)	Acquire lock
releaseLock(key, holder)	Release lock
createBranch(name)	Create branch
merge(source, target)	Merge branches
createSnapshot()	Create snapshot

🔗 Related Packages

Package	Description
@weave_protocol/witan	Consensus, communication & governance
@weave_protocol/mund	Secret & threat scanning
@weave_protocol/hord	Secure vault & sandbox
@weave_protocol/api	Universal REST API

📄 License

Apache 2.0

Made with ❤️ for AI Safety