testing-review-contract

Define AgentHub v1.0+ testing layers, contract validation, and CI quality gates.

Updated May 19, 2026
One-click install
npx skills add https://github.com/zxc1a1a1/Multi_Agent-AgentHub --skill testing-review-contract
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: testing-review-contract
Source: https://github.com/zxc1a1a1/Multi_Agent-AgentHub/tree/main/.agents/skills/testing-review-contract
Command: npx skills add https://github.com/zxc1a1a1/Multi_Agent-AgentHub --skill testing-review-contract

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill prevents fragile or unsafe changes in AgentHub by enforcing a contract-first, security-aware test and review standard across services and runtime behaviors.

Core Features & Use Cases

  • Contract-first and schema validation: Ensures every cross-boundary interface has valid/invalid fixtures and fails safely before real execution.
  • Deterministic CI testing layers: Defines a test matrix covering unit, component/store, adapter/converter, service integration, and cross-process integration (Gateway ↔ Orchestrator).
  • Failure, streaming, artifacts, and security guardrails: Requires replayable streaming/SSE tests, artifact-to-runtime capability validation, fallback/retry correctness, and security regression checks (redaction, iframe sandboxing, confirm_action for high-risk tools).
  • PR Review checklist and CI quality gates: Makes merge contingent on passing the required gates and verifying that contracts, fixtures, and process separation remain intact.

Quick Start

Use the testing-review-contract Skill as your PR and CI checklist by updating/adding schema/fixture coverage for every affected contract and running the required unit/contract/security checks before requesting review.

Frequently Asked Questions about testing-review-contract

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce contract-first testing for multi-agent orchestration services?▼

Contract-first testing enforces strict schema validation and deterministic fixtures across multi-agent boundaries. This standard ensures interfaces fail safely using valid and invalid inputs before real execution, blocking unsafe merges across cross-process services like Gateway and Orchestrator.

What is the best way to test SSE streaming events in a CI pipeline?▼

Testing SSE streaming events requires replayable streaming tests within your CI pipeline. This approach validates streaming behaviors deterministically, ensuring that cross-protocol changes and artifact-to-runtime capabilities are verified before integration.

How do I set up CI quality gates to block unsafe merges across microservices?▼

CI quality gates block unsafe merges by making PR reviews contingent on passing defined test matrices. You set up gates covering unit, component, and cross-process integration tests, ensuring contracts, fixtures, and process separation remain intact.

Does contract-first schema validation work with Docker demo paths and persistence layers?▼

Contract-first schema validation applies to Docker demo paths and persistence layers. It requires deterministic fake inputs and strict fixture rules to validate cross-boundary interfaces, ensuring changes across these runtime behaviors fail safely.

Why do I need security regression checks for high-risk agent tools?▼

Security regression checks are needed to prevent unsafe changes by validating redaction, iframe sandboxing, and confirm_action for high-risk tools. These controls ensure security guardrails remain intact during cross-service and cross-protocol modifications.

What are the limitations of relying on unit tests for multi-agent orchestration changes?▼

Unit tests alone cannot verify cross-process integration or streaming behaviors. Limitations include missing failure-path coverage, fallback correctness, and security regression controls, requiring a comprehensive test matrix to prevent fragile multi-agent changes.