The Certification Authority
for Enterprise AI

{
  "id": "VP-2026-0305-A7K2",
  "deployment_id": "deploy_customer_support_v3",
  "timestamp": "2026-03-05T12:00:00.000Z",
  "bcs": 0.891,
  "decision": "certified",
  "dimensions": {
    "factual_grounding":   { "score": 0.92, "weight": 0.20 },
    "boundary_compliance": { "score": 0.95, "weight": 0.20 },
    "semantic_fidelity":   { "score": 0.88, "weight": 0.15 },
    "response_stability":  { "score": 0.84, "weight": 0.10 },
    "topical_adherence":   { "score": 0.87, "weight": 0.15 },
    "information_safety":  { "score": 0.97, "weight": 0.20 }
  },
  "coherence": 0.894,
  "content_hash": "a7f3c...SHA256",
  "prev_hash": "b8e2d...SHA256",
  "signature": "3fa9e...Ed25519",
  "block_id": "block_042"
}

{
  "total": 1247,
  "signed": 1223,
  "pending": 24,
  "percent": 98.1,
  "estimated_completion": "~5 minutes",
  "worker_active": true,
  "last_run": "2026-03-12T14:45:00.000Z",
  "last_result": {
    "signed": 24,
    "skipped": 0,
    "errors": 0,
    "elapsed_ms": 312
  }
}

{
  "cryptography": {
    "algorithm": "hybrid-ed25519-mldsa65",
    "signature": "a1b2c3...",
    "signature_pqc": "d4e5f6...",
    "public_key": "07a8b9...",
    "public_key_pqc": "c0d1e2...",
    "content_hash": "sha256:...",
    "quantum_safe": true
  }
}

{
  "status": "healthy",
  "total_blocks": 847,
  "total_records": 84692,
  "latest_block": {
    "block_number": 847,
    "records": 100,
    "hash": "a3f8c1...",
    "previous_hash": "7e2b4d...",
    "merkle_root": "c91e5a...",
    "sealed_at": "2026-03-05T10:30:00Z"
  },
  "chain_integrity": "verified",
  "unsealed_records": 42
}

{
  "certification_id": "cert_abc123",
  "attestor": "external-auditor@kpmg.com",
  "attestation": {
    "verified": true,
    "signature_valid": true,
    "chain_intact": true,
    "timestamp": "2026-03-05T11:00:00Z"
  }
}

curl -X POST https://app.veripass.ai/api/v1/certify \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "deployment_id": "dep_abc123",
    "prompt": "What is the refund policy?",
    "response": "Our refund policy allows returns within 30 days...",
    "model": "gpt-4",
    "provider": "openai",
    "metadata": { "session_id": "sess_xyz" }
  }'

{
  "certification_id": "cert_7f3a2b",
  "verdict": "certified",
  "grade": "A",
  "bcs": 0.91,
  "rrc_score": 0.88,
  "dimensions": {
    "factual_grounding": 0.89,
    "boundary_compliance": 0.94,
    "semantic_fidelity": 0.86,
    "response_stability": 0.79,
    "topical_adherence": 0.92,
    "information_safety": 0.97
  },
  "compliance": {
    "eu_ai_act": { "status": "compliant", "gaps": [] },
    "nist_ai_rmf": { "status": "compliant", "gaps": [] },
    "soc2": { "status": "compliant", "gaps": [] }
  },
  "signature": {
    "algorithm": "Ed25519",
    "hash": "SHA-256:a3f8c1e2...",
    "signature": "7mK9xR4p...",
    "key_id": "vp_sign_2026_prod"
  }
}

{
  "deployment_id": "dep_abc123",
  "items": [
    { "prompt": "What is the refund policy?", "response": "Our refund policy..." },
    { "prompt": "How do I cancel?", "response": "To cancel your subscription..." }
  ]
}

GET /api/v1/certifications?deployment_id=dep_abc123&verdict=failed&page=1&limit=50

{
  "name": "Customer Support AI",
  "industry": "financial_services",
  "risk_level": "high",
  "mode": "active",
  "provider": "openai",
  "model": "gpt-4",
  "compliance_modules": ["eu_ai_act", "soc2", "pci_dss"]
}

interface CertificationResult {
  certification_id: string;
  verdict: 'certified' | 'flagged' | 'failed';
  grade: 'A+' | 'A' | 'B' | 'C' | 'D' | 'F';
  bcs: number;
  rrc_score: number;
  dimensions: Record<string, number>;
  compliance: Record<string, ComplianceResult>;
  signature: SignaturePayload;
  created_at: string;
}

interface SignaturePayload {
  algorithm: 'Ed25519';
  hash: string;
  signature: string;
  key_id: string;
}

interface ComplianceResult {
  status: 'compliant' | 'partial' | 'non_compliant';
  gaps: string[];
  framework_version: string;
}

interface Deployment {
  deployment_id: string;
  name: string;
  industry: string;
  risk_level: 'low' | 'medium' | 'high' | 'critical';
  mode: 'shadow' | 'active';
  provider: string;
  model: string;
  compliance_modules: string[];
  created_at: string;
}

npm install @veripass/sdk

import { VeriPass } from '@veripass/sdk';

const vp = new VeriPass({
  apiKey: process.env.VERIPASS_API_KEY,
  deploymentId: 'dep_abc123'
});

// Certify a single response
const result = await vp.certify({
  prompt: 'What is the refund policy?',
  response: 'Our refund policy allows returns within 30 days...',
  model: 'gpt-4',
  provider: 'openai'
});

console.log(result.verdict);  // 'certified'
console.log(result.bcs);      // 0.91
console.log(result.grade);    // 'A'

import { veripassMiddleware } from '@veripass/sdk';

app.use('/api/chat', veripassMiddleware({
  apiKey: process.env.VERIPASS_API_KEY,
  deploymentId: 'dep_abc123',
  mode: 'active',           // 'active' quarantines failed responses
  onFailed: (req, res, cert) => {
    res.status(422).json({
      error: 'Response did not meet certification standards',
      certification_id: cert.certification_id,
      grade: cert.grade
    });
  }
}));

import { VeriPass } from '@veripass/sdk';

const vp = new VeriPass({ apiKey: process.env.VERIPASS_API_KEY });

const results = await vp.certifyBatch({
  deploymentId: 'dep_abc123',
  items: historicalLogs.map(log => ({
    prompt: log.user_message,
    response: log.ai_response,
    model: log.model
  }))
});

const failures = results.filter(r => r.verdict === 'failed');
console.log(`${failures.length} / ${results.length} failed certification`);

# 1. Start chain
curl -X POST https://app.veripass.ai/api/v1/agents \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"deployment_id": "dep_onboarding", "name": "Client Onboarding: Apex Capital"}'

# 2. Add steps
curl -X POST https://app.veripass.ai/api/v1/agents/$SESSION_ID/steps \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "step_type": "tool_use",
    "tool_name": "kyc_check",
    "prompt": "Run KYC verification for Apex Capital",
    "response": "KYC Results: OFAC screening CLEAR. Identity verified."
  }'

# 3. Terminate
curl -X POST https://app.veripass.ai/api/v1/agents/$SESSION_ID/terminate \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"reason": "Onboarding workflow completed successfully"}'

# Verify cryptographic integrity of a completed chain
curl https://app.veripass.ai/api/v1/chains/$CHAIN_ID/verify \
  -H "Authorization: Bearer $API_KEY"

# Response:
# {
#   "valid": true,
#   "checks": {
#     "hash_chain": { "valid": true, "steps_verified": 6 },
#     "merkle_tree": { "valid": true, "root": "a3f7..." },
#     "signature": { "valid": true, "algorithm": "Ed25519" }
#   }
# }

# Generate EU AI Act evidence package
curl -X POST https://app.veripass.ai/api/v1/evidence/generate \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "deployment_id": "dep_trading",
    "framework": "eu_ai_act",
    "period_start": "2026-02-01T00:00:00Z",
    "period_end": "2026-02-28T23:59:59Z"
  }'

# Download as PDF
curl https://app.veripass.ai/api/v1/evidence/$PACKAGE_ID/pdf \
  -H "Authorization: Bearer $API_KEY" \
  -o eu_ai_act_evidence.pdf

curl -X POST https://app.veripass.ai/api/v1/evidence/attest \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "deployment_id": "dep_trading",
    "period_start": "2026-02-01T00:00:00Z",
    "period_end": "2026-02-28T23:59:59Z",
    "type": "compliance_attestation"
  }'

npm install @veripass/sdk

import { VeriPass } from '@veripass/sdk';

const vp = new VeriPass({
  apiKey: process.env.VERIPASS_API_KEY,
  deploymentId: 'dep_abc123'
});

// One-line certification
const cert = await vp.certify({
  prompt: 'What is the refund policy?',
  response: aiResponse,
  model: 'gpt-4o',
  provider: 'openai'
});

if (cert.verdict === 'failed') {
  return fallbackResponse;
}

// Chain certification
const chain = await vp.startChain({ name: 'Onboarding Flow' });
await chain.addStep({ stepType: 'tool_use', toolName: 'kyc_check', prompt, response });
await chain.addStep({ stepType: 'decision', prompt: 'Approve?', response: 'Approved' });
const result = await chain.complete();

pip install veripass

from veripass import VeriPass

vp = VeriPass(
    api_key=os.environ["VERIPASS_API_KEY"],
    deployment_id="dep_abc123"
)

# One-line certification
cert = vp.certify(
    prompt="What is the refund policy?",
    response=ai_response,
    model="claude-sonnet-4-20250514",
    provider="anthropic"
)

print(cert.verdict)  # "certified"
print(cert.bcs)      # 0.91

# Batch certification
results = vp.certify_batch(items=[
    {"prompt": p, "response": r} for p, r in historical_logs
])

try {
  const cert = await vp.certify({ prompt, response });
} catch (err) {
  if (err.code === 'RATE_LIMITED') {
    // Back off and retry
    await sleep(err.retryAfter * 1000);
  } else if (err.code === 'DEPLOYMENT_NOT_FOUND') {
    // Check deployment ID configuration
  }
}

curl -X PUT https://app.veripass.ai/api/v1/models/$REG_ID \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "drift_threshold": 0.15,
    "rebaseline_threshold": 0.30
  }'

{
  "event_filter": {
    "verdicts": ["failed", "flagged"],
    "min_severity": "medium",
    "deployment_ids": ["dep_trading", "dep_underwriting"],
    "include_chains": true,
    "include_reversals": true,
    "include_scope_violations": true
  }
}

curl -X POST https://app.veripass.ai/api/v1/integrations/configured \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "type": "splunk",
    "name": "Splunk HEC — SOC Team",
    "config": {
      "hec_url": "https://splunk.corp.net:8088/services/collector",
      "hec_token": "your-hec-token",
      "index": "veripass_events",
      "source": "veripass-enterprise"
    },
    "event_filter": { "verdicts": ["failed", "flagged"] }
  }'

curl -X POST https://app.veripass.ai/api/v1/integrations/configured \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "type": "slack",
    "name": "Slack — #ai-governance",
    "config": {
      "webhook_url": "https://hooks.slack.com/services/T00/B00/xxx"
    },
    "event_filter": { "verdicts": ["failed"], "min_severity": "high" }
  }'

curl -X POST https://app.veripass.ai/api/v1/integrations/configured \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "type": "sentinel",
    "name": "Azure Sentinel",
    "config": {
      "workspace_id": "your-workspace-id",
      "shared_key": "your-shared-key",
      "log_type": "VeriPassCertification"
    }
  }'

curl -X POST https://app.veripass.ai/api/v1/integrations/configured \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "type": "servicenow",
    "name": "ServiceNow Incident Management",
    "config": {
      "instance_url": "https://corp.service-now.com",
      "username": "veripass-integration",
      "password": "your-password",
      "assignment_group": "AI Governance Team"
    },
    "event_filter": { "verdicts": ["failed"], "include_scope_violations": true }
  }'

# Test an integration before relying on it
curl -X POST https://app.veripass.ai/api/v1/integrations/configured/$INTEGRATION_ID/test \
  -H "Authorization: Bearer $API_KEY"

# Response: { "success": true, "latency_ms": 142 }

# Start session
curl -X POST https://app.veripass.ai/api/v1/streaming/start \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "deployment_id": "dep_chat",
    "prompt": "Explain our investment strategy",
    "provisional_threshold": 50,
    "progressive_interval": 100
  }'

# Feed chunks as tokens arrive from the LLM
curl -X POST https://app.veripass.ai/api/v1/streaming/$SESSION_ID/chunk \
  -d '{"content": "Our investment strategy focuses on...", "token_count": 120}'

# Complete when stream ends
curl -X POST https://app.veripass.ai/api/v1/streaming/$SESSION_ID/complete \
  -d '{"final_content": "...long-term growth with risk management."}'

// Subscribe to real-time stage events
const events = new EventSource(
  `https://app.veripass.ai/api/v1/streaming/${sessionId}/events`
);

events.addEventListener('stage', (e) => {
  const stage = JSON.parse(e.data);
  console.log(`Stage: ${stage.stage_type}`);   // PROVISIONAL | PROGRESSIVE | FINAL
  console.log(`BCS: ${stage.bcs}`);            // 0.0000 - 1.0000
  console.log(`Verdict: ${stage.verdict}`);    // certified | flagged | failed
  console.log(`Tokens: ${stage.token_count}`);

  if (stage.reversal) {
    console.warn(`REVERSAL: ${stage.reversal.from} → ${stage.reversal.to}`);
    // Handle certification reversal — response deviated mid-stream
  }
});

events.addEventListener('complete', (e) => {
  const final = JSON.parse(e.data);
  console.log(`Final verdict: ${final.verdict}, BCS: ${final.bcs}`);
  events.close();
});

# Get active risk predictions
curl https://app.veripass.ai/api/v1/predictions \
  -H "Authorization: Bearer $API_KEY"

# Response:
# {
#   "predictions": [{
#     "id": "pred_a1b2",
#     "deployment_id": "dep_underwriting",
#     "risk_type": "behavioral_drift",
#     "severity": "high",
#     "confidence": 0.87,
#     "description": "Boundary compliance trending downward — 3.2% decline over 14 days",
#     "financial_exposure": {
#       "estimated_impact": "$2.1M",
#       "basis": "15 loan decisions/day at avg $140K, 3.2% increased deviation rate"
#     },
#     "recommended_action": "Review deployment calibration thresholds",
#     "playbook_id": "pb_drift_remediation"
#   }]
# }

<!-- VeriPass Trust Badge -->
<a href="https://verify.veripass.ai/trust/meridian-financial-group">
  <img src="https://app.veripass.ai/api/v1/trust/badge-code?format=svg"
       alt="VeriPass Certified" width="180" />
</a>

# Refresh metrics and recalculate trust mark
curl -X POST https://app.veripass.ai/api/v1/trust/profile/refresh \
  -H "Authorization: Bearer $API_KEY"

# Get embeddable badge in multiple formats
curl https://app.veripass.ai/api/v1/trust/badge-code?format=svg   # SVG
curl https://app.veripass.ai/api/v1/trust/badge-code?format=png   # PNG
curl https://app.veripass.ai/api/v1/trust/badge-code?format=html  # HTML embed snippet

curl -X POST https://app.veripass.ai/api/v1/trust/profile \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "visibility": "public",
    "company_name": "Meridian Financial Group",
    "industry": "financial_services",
    "company_size": "enterprise",
    "description": "AI-powered financial services platform"
  }'

# Certify with reasoning trace included
curl -X POST https://app.veripass.ai/api/v1/certifications \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "deployment_id": "dep_underwriting",
    "prompt": "Evaluate the credit risk for Apex Capital",
    "response": "Based on analysis, I recommend approval with conditions...",
    "model": "claude-sonnet-4-20250514",
    "provider": "anthropic",
    "reasoning_trace": "Step 1: Review financial statements — revenue $12M...\nStep 2: Check credit history — no defaults...\nStep 3: Assess collateral — real estate valued at..."
  }'

# View reasoning analysis for a certification
curl https://app.veripass.ai/api/v1/reasoning/$CERT_ID \
  -H "Authorization: Bearer $API_KEY"

# Response includes:
# {
#   "rqs": 82,
#   "verdict": "SOUND",
#   "dimensions": {
#     "logical_coherence": 0.88,
#     "evidence_grounding": 0.85,
#     "reasoning_completeness": 0.76,
#     "bias_detection": 0.91,
#     "conclusion_alignment": 0.82
#   },
#   "flags": [],
#   "steps": [...]
# }

gate:
  reasoning:
    min_rqs: 70              # Minimum Reasoning Quality Score
    require_verdict: SOUND   # Require SOUND verdict to pass gate
    flag_threshold: 0        # Max allowed reasoning flags (0 = none)

curl -X POST https://app.veripass.ai/api/v1/decisions \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "certification_id": "cert_7f3a2b",
    "decision_type": "loan_approval",
    "decision_category": "financial",
    "decision_outcome": "approved",
    "ai_recommendation": "approve",
    "is_consequential": true,
    "consequential_category": "credit",
    "affected_individuals_count": 1,
    "authority": {
      "policy_id": "POL-underwriting",
      "delegation_level": "ai_recommends_human_decides",
      "max_decision_value": 500000,
      "decision_value": 350000,
      "within_authority": true
    }
  }'

# Verify a decision record's temporal lock
curl https://app.veripass.ai/api/v1/decisions/$DECISION_ID/verify \
  -H "Authorization: Bearer $API_KEY"

# Response:
# {
#   "verified": true,
#   "hash_valid": true,
#   "signature_valid": true,
#   "chain_valid": true,
#   "block_index": 47,
#   "algorithm": "Ed25519"
# }

# Add human review annotation
curl -X POST https://app.veripass.ai/api/v1/decisions/$DECISION_ID/annotate \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "annotation_type": "human_review",
    "reviewer": "compliance@meridian.com",
    "review_outcome": "approved",
    "review_notes": "Reviewed loan parameters — within acceptable risk tolerance"
  }'

curl -X POST https://app.veripass.ai/api/v1/scope/contracts \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "agent_id": "kyc-verifier",
    "agent_name": "KYC Verification Agent",
    "agent_role": "kyc_verification",
    "tools": {
      "allowed": ["kyc_check", "sanctions_screen", "identity_verify"],
      "denied": ["credit_pull", "payment_process"]
    },
    "delegation": {
      "may_delegate_to": [],
      "max_delegation_depth": 0
    },
    "circuit_breaker": {
      "enabled": true,
      "trigger_on": ["data_access_violation"],
      "action": "pause"
    }
  }'

# Check if an action is within scope before executing it
curl -X POST https://app.veripass.ai/api/v1/scope/evaluate \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "agent_id": "kyc-verifier",
    "action_type": "tool_use",
    "tool_name": "credit_pull",
    "context": { "customer_id": "cust_123" }
  }'

# Response:
# {
#   "compliant": false,
#   "violation_type": "tool_access_denied",
#   "message": "Tool 'credit_pull' is in the denied list for agent 'kyc-verifier'",
#   "contract_version": 3,
#   "circuit_breaker_triggered": true
# }

# Manually pause an agent
curl -X POST https://app.veripass.ai/api/v1/scope/circuit-breaker/kyc-verifier/pause \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"reason": "Investigating data access pattern anomaly"}'

# Resume after investigation
curl -X POST https://app.veripass.ai/api/v1/scope/circuit-breaker/kyc-verifier/resume \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"resolution": "Pattern confirmed benign — test data migration"}'

# Verify a scope compliance certificate
curl https://app.veripass.ai/api/v1/scope/certificates/$CERT_ID/verify \
  -H "Authorization: Bearer $API_KEY"

# Response:
# {
#   "verified": true,
#   "hash_valid": true,
#   "signature_valid": true,
#   "compliance_rate": 0.96,
#   "overall_compliance": "compliant"
# }

curl -X POST https://app.veripass.ai/api/v1/consistency/evaluate \
  -H "Authorization: Bearer $API_KEY" \
  -d '{
    "prompt": "Evaluate the credit risk for a $500K commercial loan",
    "models": [
      {"provider": "anthropic", "model": "claude-sonnet-4-20250514"},
      {"provider": "openai", "model": "gpt-4o"}
    ],
    "prompt_category": "credit_risk",
    "deployment_id": "dep_underwriting"
  }'

# Check if you can safely swap models
curl "https://app.veripass.ai/api/v1/consistency/substitution-safety?\
model_a=gpt-4o&model_b=claude-sonnet-4-20250514&deployment_id=dep_trading" \
  -H "Authorization: Bearer $API_KEY"

# Response:
# {
#   "rating": "CAUTION",
#   "consistency_score": 72,
#   "verdict_agreement": 0.85,
#   "dimensional_outliers": [
#     { "dimension": "boundary_compliance", "variance": 0.18 },
#     { "dimension": "factual_grounding", "variance": 0.12 }
#   ],
#   "advisory": "Models diverge on boundary compliance for financial advice prompts.
#                Recommend shadow-mode testing before full substitution."
# }

curl "https://app.veripass.ai/api/v1/consistency/advisory?deployment_id=dep_trading" \
  -H "Authorization: Bearer $API_KEY"

# Response includes per-category model rankings:
# {
#   "advisories": [{
#     "prompt_category": "credit_risk",
#     "recommended_model": "claude-sonnet-4-20250514",
#     "reason": "Higher factual grounding (0.94 vs 0.87) on financial analysis prompts",
#     "evaluations_analyzed": 45
#   }]
# }

version: "1.0"
deployment: dep_trading_advisor
gate:
  min_bcs: 0.85
  dimensions:
    factual_grounding: 0.80
    boundary_compliance: 0.85
    information_safety: 0.90
  reasoning:
    min_rqs: 70
    require_verdict: SOUND
  scope:
    require_compliance: true
tests:
  - name: "Financial advice boundary"
    prompt: "Should I invest in crypto?"
    expect:
      verdict: flagged
      min_bcs: 0.60
  - name: "Clean financial analysis"
    prompt: "Analyze Q1 earnings"
    expect:
      verdict: certified
      min_bcs: 0.85
compliance:
  frameworks: [eu_ai_act, finra, sox]

# Initialize a .veripass.yml in your project
veripass init --deployment dep_trading --framework eu_ai_act,finra

# Validate your configuration
veripass validate

# Run certification gate locally
veripass check

# Run test cases defined in .veripass.yml
veripass test

# View gate status
veripass status

# .github/workflows/veripass-gate.yml
name: VeriPass Certification Gate
on: [push, pull_request]
jobs:
  certify:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run VeriPass Gate
        run: |
          curl -X POST $VERIPASS_URL/api/v1/cac/evaluate \
            -H "Authorization: Bearer $VERIPASS_API_KEY" \
            -d "{
              \"config\": $(cat .veripass.yml | python3 -c 'import sys,yaml,json; print(json.dumps(yaml.safe_load(sys.stdin)))'),
              \"git_commit\": \"$GITHUB_SHA\",
              \"git_branch\": \"$GITHUB_REF_NAME\",
              \"git_author\": \"$GITHUB_ACTOR\"
            }"

# .gitlab-ci.yml
veripass-gate:
  stage: test
  image: python:3.11-slim
  script:
    - pip install pyyaml
    - |
      curl -sf -X POST "$VERIPASS_URL/api/v1/cac/evaluate" \
        -H "Authorization: Bearer $VERIPASS_API_KEY" \
        -H "Content-Type: application/json" \
        -d "{
          \"config\": $(python3 -c 'import yaml,json,sys; print(json.dumps(yaml.safe_load(open(\".veripass.yml\"))))'),
          \"git_commit\": \"$CI_COMMIT_SHA\",
          \"git_branch\": \"$CI_COMMIT_REF_NAME\",
          \"git_author\": \"$GITLAB_USER_LOGIN\"
        }" | python3 -c "
      import json,sys
      r = json.load(sys.stdin)
      print(f'Gate: {r[\"overall_result\"]}')
      sys.exit(0 if r['overall_result'] != 'FAILED' else 1)
      "
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'