dsg-hybrid-agent

Files (9)

• README.md
• SKILL.md
• install.sh
• README.md · references/
• recording-guide.md · references/
• README.md · templates/
• multi-agent-template.md · templates/
• task-template.md · templates/
• task-template.yaml · templates/

SKILL.md (first lines)

# DSG Hybrid Agent Skill

## Overview

This skill provides a **multi-agent workflow executor** for DSG Control Plane that combines:
- **ROM DOM Simulation** (fast, free, deterministic) - runs on Vercel
- **Real Browser Execution** (Browserbase/Stagehand) - for auth/gate eval
- **Verification Gates** (T4 deterministic merge) - ensures sim ≡ real

## Architecture

```
┌─────────────────────────────────────────────────────────────────┐
│                    HYBRID AGENT WORKFLOW                        │
├─────────────────────────────────────────────────────────────────┤
│  Task YAML → PARSE → SIM SESSION → REAL BROWSER (if needed)    │
│       │           │           │              │                  │
│       ▼           ▼           ▼              ▼                  │
│   [Goal]    [Steps]    [Engine]         [Stagehand]             │
│                              │              │                  │
│                              └──────┬───────┘                  │
│                                     ▼                          │
│                            [VERIFICATION GATE T4]             │
│                                     │                          │
│                                     ▼                          │
│                              [MERGED RESULT]                   │
└─────────────────────────────────────────────────────────────────┘
```

## Key Components

### 1. ROM DOM Registry (`src/rom-dom/`)
Pre-recorded DOM snapshots for all DSG pages:
- **Public**: landing, delivery-proof, readiness-report, health, mcp-manifest, compliance-annex4, ccvs-status
- **Protected**: login, hermes-dashboard, gate-evaluate

Each ROM contains:
- Selectors (semantic → CSS)
- Forms (fields, validation, submit)
- Actions (click, type, extract, wait, api-call)
- Simulation rules (input → predicted output)
- Browser actions (Playwright commands)

### 2. Simulation Engine (`src/lib/simulation/engine.ts`)
Pure TypeScript, runs on Vercel:
- `ROMSimulationEngine` - per-ROM simulation
- `SimulationSession` - multi-step workflow with context
- `SimulationEngineFactory` - create engines

### 3. Hybrid API (`app/api/agent/hybrid/route.ts`)
Three modes:
- `sim-only` - Fast, free, no real browser
- `hybrid` - Simulate first, real for auth steps, verify at T4
- `real-only` - Full real browser (slow, costs)

### 4. Task Definitions (`tasks/`)
YAML workflows:
- `login-and-gate-eval.yaml` - Full login + gate evaluation
- `public-recon.yaml` - Public endpoint reconnaissance
- `delivery-proof-scan.yaml` - Delivery proof scanning
- `readiness-check.yaml` - Production readiness
- `ci-cd-pipeline.yaml` - Full CI/CD verification

## Quick Start

### 1. Run Public Recon (SIM ONLY - Free, Instant)
```bash
curl -X POST https://your-app.vercel.app/api/agent/hybrid \
  -H "Content-Type: application/json" \
  -d '{"goal": "Public recon", "mode": "sim-only", "steps": [
    {"type": "api-call", "rom": "health"},
    {"type": "api-call", "rom": "mcp-manifest"},
    {"type": "api-call", "rom": "compliance-annex4"}
  ]}'
```

### 2. Run Full Login + Gate Eval (HYBRID)
```bash
curl -X POST https://your-app.vercel.app/api/agent/hybrid \
  -H "Content-Type: application/json" \
  -d @tasks/login-and-gate-eval.yaml
```

### 3. Use from Hermes Agent
```typescript
// In Hermes agent context
const result = await fetch('https://tdealer01-crypto-dsg-control-plane.vercel.app/api/agent/hybrid', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    goal: 'Login and evaluate gate',
    mode: 'hybrid',
    steps: [...]
  })
});
```

## Multi-Agent Parallel Execution

This skill supports **parallel agent execution** for independent workflows:

```yaml
# Parallel task group
agentGroup:
  - agent: recon-agent
    task: public-recon.yaml
  - agent: compliance-agent
    task: compliance-check.yaml
  - agent: readiness-agent
    task: readiness-check.yaml
```

Each agent runs in isolation with its own `SimulationSession`, then results are merged at T4 gate.

## Verification Gates (T4 Deterministic Merge)

Every hybrid step supports verification:
```yaml
verification:

From tdealer01-crypto/tdealer01-crypto-dsg-control-plane, MIT.

More from tdealer01-crypto/tdealer01-crypto-dsg-control-plane