roster-formal-verify

Run formal verification gates for critical tasks using Rocq or Quint.

2|2|Updated Mar 17, 2026
One-click install
npx skills add https://github.com/mathiasbourgoin/roster --skill roster-formal-verify
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: roster-formal-verify
Source: https://github.com/mathiasbourgoin/roster/tree/main/.opencode/skills/roster-formal-verify
Command: npx skills add https://github.com/mathiasbourgoin/roster --skill roster-formal-verify

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Standard QA processes are insufficient for critical software tasks that require provable correctness and auditable evidence of verification. This skill provides a dedicated formal verification gate that integrates directly into the roster pipeline, eliminating manual verification steps and ensuring consistent, traceable proof validation for high-stakes development work.

Core Features & Use Cases

  • Automated Tool Resolution: Detects the correct formal verification backend (Rocq or Quint) for your project via capability tag scanning, no manual configuration required.
  • Deterministic Checker Re-validation: Delegates compilation and trace generation to the appropriate formal skill, then re-runs the underlying checker (coqchk or connect bridge replay) itself to avoid relying on unverified self-reports from sub-agents.
  • Standardized Evidence Tiering: Emits clear, auditable evidence tiers (E0p for Rocq proofs, E0m/E0m-abstract for Quint model verification, E1 for declined verification) with full traceability between proofs, implementation, and user requirements.
  • Use Case: For a team developing safety-critical embedded software or audited smart contracts, this skill replaces the standard QA gate for --critical tasks, ensuring all formal verification steps are completed, validated, and documented before proceeding to review and deployment.

Quick Start

Use the roster-formal-verify skill to run formal verification for your critical task and generate the required evidence tier report as part of your pipeline workflow.

Frequently Asked Questions about roster-formal-verify

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

FAQPage Schema
How does formal verification ensure provable correctness for safety-critical software beyond standard QA?

Formal verification ensures provable correctness by using mathematical proofs through Rocq or Quint, replacing standard QA gates for critical tasks with deterministic checker re-validation and auditable evidence tiering. This provides full traceability between proofs, implementation, and user requirements.

What is the best way to automate formal proof validation in a development pipeline?

Automating formal proof validation in a development pipeline requires a dedicated verification gate that detects the correct backend via capability tag scanning, delegates compilation, and re-runs the underlying checker itself to avoid relying on unverified self-reports from sub-agents.

Can I use Rocq and Quint for automated formal verification of smart contracts?

Yes, you can use Rocq and Quint for automated formal verification of smart contracts. The system detects the correct backend via capability tag scanning and generates standardized evidence tiers, such as E0p for Rocq proofs or E0m for Quint model verification.

How do evidence tiers work when verifying critical tasks with formal methods?

Evidence tiers work by categorizing verification outputs into auditable levels: E0p for Rocq proofs, E0m or E0m-abstract for Quint model verification, and E1 for declined verification. This ensures full traceability between formal proofs, implementation, and user requirements.

Why does formal verification require deterministic checker re-validation instead of trusting sub-agent reports?

Deterministic checker re-validation is required because relying on unverified self-reports from sub-agents is insufficient for high-assurance software. The system delegates compilation and trace generation, then independently re-runs the underlying checker to guarantee provable correctness.

When do I need to replace standard QA with a formal verification gate?

You need to replace standard QA with a formal verification gate when developing safety-critical embedded software or audited smart contracts that require provable correctness, deterministic validation, and auditable evidence of verification before proceeding to review and deployment.