QuDAG

# QuDAG Development Configuration

## QuDAG Build Commands
- `cargo build`: Build QuDAG core components
- `cargo build --release`: Build optimized QuDAG release
- `cargo test`: Run Rust unit and integration tests
- `wasm-pack build --target web`: Build WASM package for browsers
- `wasm-pack build --target nodejs`: Build WASM package for Node.js
- `npm run build`: Build TypeScript/JavaScript components
- `npm run test`: Run JavaScript/WASM integration tests
- `npm run test:crypto`: Run quantum cryptography tests
- `npm run test:network`: Run P2P networking tests
- `npm run lint`: Run ESLint and format checks
- `npm run typecheck`: Run TypeScript type checking
- `./claude-flow --help`: Show all available commands

## QuDAG CLI Operations
- `qudag start [--port 8080] [--bootstrap-peers <peers>]`: Start QuDAG node
- `qudag peer list`: List connected peers
- `qudag peer connect <multiaddr>`: Connect to specific peer
- `qudag address generate [--type quantum|shadow|onion]`: Generate addresses
- `qudag address resolve <dark-domain>`: Resolve dark domain
- `qudag vault create <name>`: Create new vault
- `qudag vault unlock <name>`: Unlock vault for operations
- `qudag key generate [--algorithm ml-dsa|ml-kem|hqc]`: Generate quantum keys
- `qudag sign <message> [--key <path>]`: Sign message with quantum signature
- `qudag encrypt <data> [--recipient <address>]`: Encrypt with quantum cryptography
- `qudag dark register <domain> [--fingerprint <fp>]`: Register dark domain
- `qudag network status`: Show network topology and health

## QuDAG Exchange Operations
- `qudag exchange create-account --name <name>`: Create new rUv token account
- `qudag exchange balance --account <name>`: Check account balance
- `qudag exchange transfer --from <sender> --to <receiver> --amount <n>`: Transfer rUv tokens
- `qudag exchange list-accounts`: List all exchange accounts
- `qudag exchange fee-info [--examples]`: Show fee model information
- `qudag exchange verify-agent <account> --proof-path <path>`: Verify agent for reduced fees
- `qudag exchange calculate-fee --account <name> --amount <n>`: Calculate transaction fee
- `qudag exchange immutable-status`: Check immutable deployment status
- `qudag exchange deploy-immutable --key-path <path>`: Deploy in immutable mode

## QuDAG Exchange Business Plan
- `qudag exchange business-plan enable [--auto-distribution]`: Enable payout features
- `qudag exchange business-plan disable`: Disable business plan features
- `qudag exchange business-plan status`: Show current business plan status
- `qudag exchange business-plan configure threshold <amount>`: Set payout threshold
- `qudag exchange business-plan configure system-fee <percentage>`: Set system fee
- `qudag exchange business-plan contributors register <id> <role> <vault>`: Register contributor
- `qudag exchange business-plan contributors list`: List all contributors
- `qudag exchange business-plan contributors show <id>`: Show contributor details
- `qudag exchange business-plan payouts [--limit <n>]`: View payout history

## Claude-Flow Complete Command Reference

### Core System Commands
- `./claude-flow start [--ui] [--port 3000] [--host localhost]`: Start orchestration system with optional web UI
- `./claude-flow status`: Show comprehensive system status
- `./claude-flow monitor`: Real-time system monitoring dashboard
- `./claude-flow config <subcommand>`: Configuration management (show, get, set, init, validate)

### Agent Management
- `./claude-flow agent spawn <type> [--name <name>]`: Create AI agents (researcher, coder, analyst, etc.)
- `./claude-flow agent list`: List all active agents
- `./claude-flow spawn <type>`: Quick agent spawning (alias for agent spawn)

### Task Orchestration
- `./claude-flow task create <type> [description]`: Create and manage tasks
- `./claude-flow task list`: View active task queue
- `./claude-flow workflow <file>`: Execute workflow automation files

### Memory Management
- `./claude-flow memory store <key> <data>`: Store persistent data across sessions
- `./claude-flow memory get <key>`: Retrieve stored information
- `./claude-flow memory list`: List all memory keys
- `./claude-flow memory export <file>`: Export memory to file
- `./claude-flow memory import <file>`: Import memory from file
- `./claude-flow memory stats`: Memory usage statistics
- `./claude-flow memory cleanup`: Clean unused memory entries

### SPARC Development Modes
- `./claude-flow sparc "<task>"`: Run orchestrator mode (default)
- `./claude-flow sparc run <mode> "<task>"`: Run specific SPARC mode
- `./claude-flow sparc tdd "<feature>"`: Test-driven development mode
- `./claude-flow sparc modes`: List all 17 available SPARC modes

Available SPARC modes: orchestrator, coder, researcher, tdd, architect, reviewer, debugger, tester, analyzer, optimizer, documenter, designer, innovator, swarm-coordinator, memory-manager, batch-executor, workflow-manager

### Swarm Coordination
- `./claude-flow swarm "<objective>" [options]`: Multi-agent swarm coordination
- `--strategy`: research, development, analysis, testing, optimization, maintenance
- `--mode`: centralized, distributed, hierarchical, mesh, hybrid
- `--max-agents <n>`: Maximum number of agents (default: 5)
- `--parallel`: Enable parallel execution
- `--monitor`: Real-time monitoring
- `--output <format>`: json, sqlite, csv, html

### MCP Server Integration
- `./claude-flow mcp start [--port 3000] [--host localhost]`: Start MCP server
- `./claude-flow mcp status`: Show MCP server status
- `./claude-flow mcp tools`: List available MCP tools

### Claude Integration
- `./claude-flow claude auth`: Authenticate with Claude API
- `./claude-flow claude models`: List available Claude models
- `./claude-flow claude chat`: Interactive chat mode

### Session Management
- `./claude-flow session`: Manage terminal sessions
- `./claude-flow repl`: Start interactive REPL mode

### Enterprise Features
- `./claude-flow project <subcommand>`: Project management (Enterprise)
- `./claude-flow deploy <subcommand>`: Deployment operations (Enterprise)
- `./claude-flow cloud <subcommand>`: Cloud infrastructure management (Enterprise)
- `./claude-flow security <subcommand>`: Security and compliance tools (Enterprise)
- `./claude-flow analytics <subcommand>`: Analytics and insights (Enterprise)

### Project Initialization
- `./claude-flow init`: Initialize Claude-Flow project
- `./claude-flow init --sparc`: Initialize with full SPARC development environment

## Quantum Cryptography Workflows

### Key Management
- `qudag key generate --algorithm ml-dsa`: Generate ML-DSA signing keys
- `qudag key generate --algorithm ml-kem`: Generate ML-KEM encryption keys  
- `qudag key generate --algorithm hqc`: Generate HQC hybrid encryption keys
- `qudag key list`: List all generated keys
- `qudag key export <key-id> [--format pem|jwk]`: Export public keys
- `qudag key import <file>`: Import key from file

### Cryptographic Operations
- `qudag sign <message> --key <key-id>`: Create quantum-resistant signature
- `qudag verify <signature> <message> --key <public-key>`: Verify signature
- `qudag encrypt <data> --recipient <public-key>`: Quantum-resistant encryption
- `qudag decrypt <ciphertext> --key <private-key>`: Decrypt data
- `qudag hybrid-encrypt <data> --recipients <key1,key2>`: Multi-recipient encryption

## Dark Addressing Workflows

### Domain Management
- `qudag dark register <domain.dark>`: Register new dark domain
- `qudag dark resolve <domain.dark>`: Resolve dark domain to addresses
- `qudag dark list`: List registered dark domains
- `qudag dark update <domain.dark> --address <new-addr>`: Update domain mapping
- `qudag dark revoke <domain.dark>`: Revoke dark domain registration

### Address Generation
- `qudag address generate --type quantum`: Generate quantum fingerprint address
- `qudag address generate --type shadow`: Generate shadow address for privacy
- `qudag address generate --type onion`: Generate onion-style routing address
- `qudag address derive --from <master-key>`: Derive hierarchical addresses
- `qudag address validate <address>`: Validate address format and checksum

### Fingerprint Operations
- `qudag fingerprint create --data <input>`: Create quantum fingerprint
- `qudag fingerprint verify <fingerprint> --data <input>`: Verify fingerprint
- `qudag fingerprint collision-test <fp1> <fp2>`: Test for collisions

## Network Operations

### Peer Management
- `qudag peer bootstrap --seeds <seed-nodes>`: Bootstrap with seed nodes
- `qudag peer connect <multiaddr>`: Connect to specific peer
- `qudag peer disconnect <peer-id>`: Disconnect from peer
- `qudag peer ban <peer-id>`: Ban malicious peer
- `qudag peer whitelist <peer-id>`: Add peer to whitelist
- `qudag peer topology`: Show network topology map

### NAT Traversal & Routing
- `qudag nat configure --upnp`: Configure UPnP port mapping
- `qudag nat status`: Check NAT traversal status
- `qudag route onion --hops <count>`: Configure onion routing
- `qudag route direct --peer <peer-id>`: Establish direct route
- `qudag tunnel create --to <destination>`: Create encrypted tunnel

### Network Monitoring
- `qudag network health`: Check network health metrics
- `qudag network latency --peer <peer-id>`: Measure peer latency
- `qudag network bandwidth --test`: Run bandwidth tests
- `qudag network consensus --status`: Check consensus status

## WASM Development

### Build Operations
- `wasm-pack build --target web --out-dir pkg`: Build for web browsers
- `wasm-pack build --target nodejs --out-dir pkg-nodejs`: Build for Node.js
- `wasm-pack build --target bundler --out-dir pkg-bundler`: Build for bundlers
- `wasm-pack test --headless --chrome`: Run WASM tests in Chrome
- `wasm-pack test --node`: Run WASM tests in Node.js

### Package Management
- `npm publish pkg/`: Publish WASM package to npm
- `npm pack pkg/`: Create tarball for local testing
- `npm install @qudag/wasm`: Install QuDAG WASM package
- `npm update @qudag/wasm`: Update to latest version

### Integration Testing
- `node test-nodejs.mjs`: Test Node.js WASM integration
- `npm run test:browser`: Test browser WASM integration
- `npm run test:crypto-wasm`: Test WASM crypto operations
- `npm run benchmark`: Run WASM performance benchmarks

## Testing Workflows

### Security Testing
- `cargo test security`: Run security-focused tests
- `cargo test --features timing-attack-tests`: Run timing attack tests
- `cargo audit`: Check for security vulnerabilities
- `cargo deny check`: Check license and security compliance

### Performance Testing
- `cargo bench`: Run performance benchmarks
- `cargo test --release --features stress-tests`: Run stress tests
- `hyperfine 'qudag encrypt <large-file>'`: Benchmark crypto operations
- `perf record qudag sign <message>`: Profile signing performance

### Integration Testing
- `docker-compose up test-network`: Start test network
- `pytest tests/integration/`: Run Python integration tests
- `npm run test:e2e`: Run end-to-end tests
- `./scripts/multi-node-test.sh`: Test multi-node scenarios

## QuDAG Development Workflows

### Quantum Crypto Research Workflow
```bash
# Start a research swarm for quantum cryptography
./claude-flow swarm "Research post-quantum cryptography standards and implementations" --strategy research --mode distributed --parallel --monitor

# Analyze quantum resistance of current algorithms
./claude-flow sparc run researcher "Compare ML-DSA vs SPHINCS+ vs Falcon quantum signature schemes"

# Store research findings for development
./claude-flow memory store "quantum_crypto_research" "ML-DSA recommended for performance, SPHINCS+ for size"
```

### QuDAG Node Development Workflow
```bash
# Start orchestration system with web UI
./claude-flow start --ui --port 3000

# Run TDD workflow for new quantum crypto feature
./claude-flow sparc tdd "ML-KEM-768 key encapsulation with perfect forward secrecy"

# Development swarm for complex DAG consensus
./claude-flow swarm "Implement QR-Avalanche consensus with quantum-resistant finality" --strategy development --mode hierarchical --max-agents 8 --monitor

# Check QuDAG node status
./claude-flow status
```

### Dark Addressing Analysis Workflow
```bash
# Analyze dark domain resolution performance
./claude-flow sparc run analyzer "Identify bottlenecks in .dark domain resolution and fingerprint verification"

# Network topology analysis swarm
./claude-flow swarm "Analyze P2P network topology and routing efficiency" --strategy analysis --mode mesh --parallel --output sqlite

# Store network analysis results
./claude-flow memory store "network_analysis" "DHT lookup latency and onion routing overhead metrics"
```

### WASM Security Workflow
```bash
# WASM security audit with safety controls
./claude-flow swarm "Audit WASM crypto bindings for timing attacks and memory leaks" --strategy maintenance --mode centralized --monitor

# Security review of quantum crypto implementations
./claude-flow sparc run reviewer "Security audit of ML-DSA signatures in WASM environment"

# Export security audit logs
./claude-flow memory export wasm_security_audit.json
```

### Vault Integration Workflow
```bash
# Research password management integration
./claude-flow sparc run researcher "Analyze QuDAG vault integration with quantum key storage"

# Develop vault CLI commands
./claude-flow sparc tdd "Vault unlock with quantum-resistant authentication"

# Test vault security across multiple environments
./claude-flow swarm "Test vault security in browser, Node.js, and native environments" --strategy testing --mode distributed --parallel
```

### Exchange and Business Plan Workflow
```bash
# Research exchange fee models and tokenomics
./claude-flow sparc run researcher "Analyze optimal fee structures for rUv token exchange with dynamic pricing"

# Develop exchange core functionality
./claude-flow sparc tdd "Implement quantum-resistant rUv token transfers with ML-DSA signatures"

# Test fee distribution system
./claude-flow swarm "Test business plan payout distribution across contributor roles" --strategy testing --mode hierarchical --monitor

# Deploy and verify immutable exchange
./claude-flow sparc run coder "Deploy exchange with immutable quantum-locked configuration"

# Store exchange configuration in memory
./claude-flow memory store "exchange_config" "Fee model: 0.1%-1.0% dynamic, verified agents 0.25%-0.5%"
./claude-flow memory store "payout_splits" "Single-agent: 95/5, Plugin-enhanced: 85/10/5, Node-ops: 80/15/5"
```

## Exchange Development Workflows

### rUv Token Management Workflow
```bash
# Create and manage rUv accounts
qudag exchange create-account --name "alice_vault"
qudag exchange create-account --name "bob_vault" --email "bob@example.com"

# Check balances and transfer tokens
qudag exchange balance --account "alice_vault"
qudag exchange transfer --from "alice_vault" --to "bob_vault" --amount 1000

# Monitor fee calculations
qudag exchange calculate-fee --account "alice_vault" --amount 10000
qudag exchange fee-info --examples
```

### Business Plan Configuration Workflow
```bash
# Enable business plan with all features
qudag exchange business-plan enable \
    --auto-distribution \
    --vault-management \
    --role-earnings \
    --bounty-rewards

# Configure payout parameters
qudag exchange business-plan configure threshold 100
qudag exchange business-plan configure system-fee 0.001

# Register contributors
qudag exchange business-plan contributors register agent-001 agent-provider alice_vault
qudag exchange business-plan contributors register plugin-002 plugin-creator bob_vault --custom-percentage 0.12

# Monitor payouts
qudag exchange business-plan status
qudag exchange business-plan payouts --limit 50
```

### Exchange Security Workflow
```bash
# Verify agent for reduced fees
qudag exchange verify-agent "alice_vault" --proof-path ./proofs/alice_kyc.proof

# Deploy immutable exchange
qudag exchange deploy-immutable --key-path ./keys/quantum_master.key

# Check immutable status
qudag exchange immutable-status --format json

# Audit exchange operations
./claude-flow swarm "Audit exchange smart contract for quantum resistance and timing attacks" --strategy maintenance --mode centralized
```

## QuDAG Integration Patterns

### Memory-Driven Quantum Coordination
Use Memory to coordinate quantum crypto information across multiple SPARC modes and swarm operations:

```bash
# Store quantum crypto architecture decisions
./claude-flow memory store "quantum_architecture" "ML-DSA signatures with ML-KEM-768 key exchange and HQC backup"

# All subsequent operations reference quantum architecture
./claude-flow sparc run coder "Implement quantum key generation based on quantum_architecture in memory"
./claude-flow sparc run tester "Create quantum resistance tests for crypto architecture"
./claude-flow memory store "key_rotation_policy" "Rotate ML-KEM keys every 1000 operations or 24 hours"
```

### Multi-Stage QuDAG Development
Coordinate complex QuDAG development through staged execution:

```bash
# Stage 1: Quantum crypto research and planning
./claude-flow sparc run researcher "Research NIST post-quantum cryptography standards"
./claude-flow sparc run architect "Design quantum-resistant DAG consensus architecture"

# Stage 2: Core implementation
./claude-flow sparc tdd "ML-DSA signature verification in DAG blocks"
./claude-flow sparc run coder "Implement QR-Avalanche consensus with quantum finality"

# Stage 3: Dark addressing and networking
./claude-flow sparc tdd ".dark domain registration and resolution system"
./claude-flow sparc run coder "Implement onion routing with quantum-resistant encryption"

# Stage 4: WASM integration and testing
./claude-flow sparc run coder "Bind quantum crypto operations to WASM interface"
./claude-flow sparc run tester "Comprehensive WASM security and performance testing"
./claude-flow swarm "Deploy QuDAG testnet" --strategy maintenance --mode centralized
```

### Enterprise QuDAG Integration
For enterprise environments with quantum-resistant requirements:

```bash
# QuDAG project management integration
./claude-flow project create "qudag-enterprise-node"
./claude-flow project switch "qudag-enterprise-node"

# Quantum security compliance
./claude-flow security scan --quantum-safe
./claude-flow security audit --post-quantum

# Network topology analytics and monitoring
./claude-flow analytics dashboard --network-topology
./claude-flow deploy testnet --monitor --quantum-metrics
```

## Advanced QuDAG Batch Tool Patterns

### TodoWrite Coordination for QuDAG Development
Always use TodoWrite for complex QuDAG task coordination:

```javascript
TodoWrite([
  {
    id: "quantum_crypto_architecture",
    content: "Design quantum-resistant crypto architecture with ML-DSA, ML-KEM, and HQC",
    status: "pending",
    priority: "high",
    dependencies: [],
    estimatedTime: "90min",
    assignedAgent: "quantum_architect"
  },
  {
    id: "dag_consensus_implementation",
    content: "Implement QR-Avalanche consensus with quantum-resistant finality",
    status: "pending",
    priority: "high",
    dependencies: ["quantum_crypto_architecture"],
    estimatedTime: "180min",
    assignedAgent: "consensus_team"
  },
  {
    id: "dark_addressing_system",
    content: "Develop .dark domain registration and quantum fingerprint system",
    status: "pending",
    priority: "medium",
    dependencies: ["quantum_crypto_architecture"],
    estimatedTime: "120min",
    assignedAgent: "addressing_team"
  },
  {
    id: "wasm_crypto_bindings",
    content: "Create WASM bindings for quantum crypto operations",
    status: "pending",
    priority: "medium",
    dependencies: ["quantum_crypto_architecture", "dag_consensus_implementation"],
    estimatedTime: "150min",
    assignedAgent: "wasm_team"
  },
  {
    id: "p2p_network_integration",
    content: "Integrate libp2p with onion routing and NAT traversal",
    status: "pending",
    priority: "medium",
    dependencies: ["dark_addressing_system"],
    estimatedTime: "180min",
    assignedAgent: "network_team"
  },
  {
    id: "security_testing",
    content: "Comprehensive security testing including timing attack resistance",
    status: "pending",
    priority: "high",
    dependencies: ["wasm_crypto_bindings", "p2p_network_integration"],
    estimatedTime: "240min",
    assignedAgent: "security_team"
  },
  {
    id: "exchange_implementation",
    content: "Implement rUv token exchange with business plan payout distribution",
    status: "pending",
    priority: "high",
    dependencies: ["quantum_crypto_architecture", "dag_consensus_implementation"],
    estimatedTime: "210min",
    assignedAgent: "exchange_team"
  },
  {
    id: "business_plan_testing",
    content: "Test fee distribution and contributor payout mechanisms",
    status: "pending",
    priority: "medium",
    dependencies: ["exchange_implementation"],
    estimatedTime: "120min",
    assignedAgent: "business_team"
  }
]);
```

### Task and Memory Integration for QuDAG Components
Launch coordinated agents with shared quantum crypto memory:

```javascript
// Store quantum crypto architecture in memory
Task("Quantum Architect", "Design ML-DSA/ML-KEM/HQC architecture and store specs in Memory");

// Parallel development using shared memory
Task("Crypto Team", "Implement quantum crypto operations using Memory architecture specs");
Task("DAG Team", "Implement QR-Avalanche consensus using Memory crypto specifications");
Task("Network Team", "Implement P2P networking with Memory quantum routing specifications");
Task("WASM Team", "Create WASM bindings based on Memory crypto interface specifications");

// Integration and testing coordination
Task("Integration Team", "Integrate all components using Memory coordination specifications");
Task("Security Team", "Test quantum resistance using Memory security test specifications");

// Exchange and business plan development
Task("Exchange Team", "Implement rUv token system with dynamic fee model and store configuration in Memory");
Task("Business Team", "Design payout distribution system for contributors and store splits in Memory");
```

### Multi-Node Testing Coordination
Coordinate complex multi-node QuDAG testing scenarios:

```javascript
TodoWrite([
  {
    id: "testnet_setup",
    content: "Set up 5-node QuDAG testnet with different quantum crypto configurations",
    status: "pending",
    priority: "high",
    dependencies: [],
    estimatedTime: "45min",
    assignedAgent: "devops_team"
  },
  {
    id: "consensus_testing",
    content: "Test QR-Avalanche consensus under network partitions and Byzantine faults",
    status: "pending",
    priority: "high",
    dependencies: ["testnet_setup"],
    estimatedTime: "120min",
    assignedAgent: "consensus_tester"
  },
  {
    id: "crypto_interop_testing",
    content: "Test quantum crypto interoperability between different algorithm implementations",
    status: "pending",
    priority: "medium",
    dependencies: ["testnet_setup"],
    estimatedTime: "90min",
    assignedAgent: "crypto_tester"
  },
  {
    id: "dark_domain_testing",
    content: "Test .dark domain registration and resolution across network",
    status: "pending",
    priority: "medium",
    dependencies: ["testnet_setup"],
    estimatedTime: "60min",
    assignedAgent: "addressing_tester"
  },
  {
    id: "performance_benchmarking",
    content: "Benchmark signature verification, encryption, and network throughput",
    status: "pending",
    priority: "low",
    dependencies: ["consensus_testing", "crypto_interop_testing"],
    estimatedTime: "180min",
    assignedAgent: "performance_team"
  }
]);
```

## QuDAG Code Style Preferences
- Use Rust idioms for core components (Result<T, E>, Option<T>, async/await)
- Use ES modules (import/export) syntax for JavaScript/TypeScript
- Destructure imports when possible, especially for WASM bindings
- Use TypeScript for all new JavaScript code
- Follow existing QuDAG naming conventions (quantum_*, dark_*, dag_*)
- Add comprehensive JSDoc comments for public crypto APIs
- Use async/await for all asynchronous operations
- Prefer const/let over var in JavaScript code
- Use snake_case for Rust code, camelCase for JavaScript/TypeScript
- Document all quantum crypto operations with security considerations

## QuDAG Workflow Guidelines
- Always run `cargo test` after making Rust changes
- Run `wasm-pack test` after modifying WASM bindings
- Test quantum crypto operations with timing attack resistance
- Run security audits before committing crypto changes
- Use meaningful commit messages following conventional commits
- Create feature branches for new QuDAG functionality
- Ensure all tests pass including security and performance tests
- Test WASM compatibility across Node.js and browser environments
- Validate dark domain operations in multi-node environments
- Benchmark performance impact of quantum crypto changes

## QuDAG-Specific Important Notes
- **Use TodoWrite extensively** for all complex QuDAG task coordination
- **Leverage Task tool** for parallel quantum crypto and network development
- **Store quantum architecture decisions in Memory** for cross-component coordination
- **Use batch file operations** for multi-component WASM builds
- **Test quantum resistance** of all new cryptographic implementations
- **Validate .dark domain resolution** across distributed network nodes
- **Monitor P2P network health** during development and testing
- **Check security implications** of all quantum crypto API changes
- **Enable parallel execution** with --parallel flags for network testing
- **Coordinate WASM builds** across web and Node.js targets
- **Test vault integration** with quantum key storage and retrieval
- **Validate onion routing** functionality with quantum-resistant encryption

## QuDAG Testing Requirements
- **Quantum Crypto Security**: All crypto operations must pass timing attack tests
- **WASM Compatibility**: Test all bindings in both browser and Node.js environments  
- **Network Resilience**: Test P2P functionality under network partitions
- **Dark Domain Resolution**: Validate .dark domain registration and resolution
- **Consensus Testing**: Test QR-Avalanche under Byzantine fault conditions
- **Performance Benchmarking**: Measure quantum crypto operation performance
- **Integration Testing**: Test end-to-end workflows across all components
- **Security Auditing**: Regular security audits of quantum crypto implementations

This configuration ensures optimal use of Claude Code's batch tools for QuDAG quantum-resistant development with comprehensive testing and security validation.