Professional Standards¶

professional_standards — mvp.professional_standards

Cluster: Uncategorised | Type: component | MCP Tools: 29

Overview¶

Verifies job agent outputs against real-world regulatory and professional standards as a standards-aware review aid. Maintains a jurisdiction-aware standard registry, detects likely deficiencies with severity grading, provides remediation hints, and generates audit-style reports for human review. Supports multi-jurisdiction comparison and corpus enrichment.

Standards-aware review, not compliance certification

professional_standards is useful for MVP and pilot workflows that need standards-aware checks, deficiency flags, remediation hints, and audit trails. It does not certify legal, clinical, financial, security, engineering, privacy, or other regulated-industry compliance. Checklist scores, LLM consensus, auto-remediation, and corpus/RAG grounding are decision-support signals, not professional sign-off or auditor-approved determinations.

Production use in regulated or client-facing workflows requires qualified human review, jurisdiction-specific source verification, current standards and law, validated evidence, audit controls, and any required external legal, clinical, engineering, security, or compliance assessment.

When to use:

Validating job_lawyer, job_medical_surgical, or job_pharmaceutical outputs against professional codes
Checking likely regulatory or professional-standard gaps in agent pipelines (GDPR, medical ethics, legal obligations)
Generating audit trails and review artifacts for supervised compliance workflows

Example:

from mvp.professional_standards import ProfessionalStandardsBlock, StandardsVerificationInput

block = ProfessionalStandardsBlock(name="standards")
result = block.infer(StandardsVerificationInput(
    job_type="lawyer",
    job_output={"advice": "The client should sign the contract immediately."},
    jurisdiction="AU",
))
# result.ok → True; result.value → StandardsVerificationOutput with grade, deficiencies

Works well with: duty_of_care, compliance, align_specs

Public API¶

`ChecklistResult`¶

Field	Type	Default
`deficiencies`	`list[StandardDeficiency]`	required
`total_checked`	`int`	required
`requirements_passed`	`int`	required

`ChecklistEvaluator`¶

Field	Type	Default
`threshold`	`float`	0.3

Methods:

`evaluate(output_text: str, standards: list, jurisdiction: str) -> ChecklistResult`¶

Evaluate output_text against per-standard requirement checklists.

`ConsensusResult`¶

Field	Type	Default
`deficiencies`	`list[StandardDeficiency]`	required
`human_review_required`	`bool`	required
`human_review_reasons`	`list[str]`	required
`evaluation_layers`	`list[str]`	required
`layer_agreements`	`dict[str, str]`	required
`total_requirements_checked`	`int`	0
`requirements_passed`	`int`	0

`ConsensusResolver`¶

Field	Type	Default
`threshold`	`float`	0.7

Methods:

`resolve(checklist_deficiencies: list[StandardDeficiency], llm_verdicts: list[LLMVerdict] | None, standards: list, job_type: str, jurisdiction: str, llm_allowed: bool = True) -> ConsensusResult`¶

Compare checklist and LLM results per standard, resolve conflicts.

`Jurisdiction(str, Enum)`¶

Supported jurisdictions.

`LLMVerdict`¶

Field	Type	Default
`standard_id`	`str`	required
`verdict`	`str`	required
`confidence`	`float`	required
`reasoning`	`str`	required
`deficiencies`	`list[dict]`	required

`LLMEvaluator`¶

Field	Type	Default
`enabled`	`bool`	True
`timeout`	`float`	60.0

Methods:

`evaluate(output_text: str, standards: list, checklist_deficiencies: list, job_type: str, jurisdiction: str, grounding_facts: list[str] | None = None) -> list[LLMVerdict] | None`¶

Evaluate output against standards using LLM.

`AutoRemediator`¶

Field	Type	Default
`max_retries`	`int`	3

Methods:

`remediate(verify_fn: Callable[[dict], StandardsVerificationOutput], job_output: dict, initial_result: StandardsVerificationOutput) -> StandardsVerificationOutput`¶

Run LLM rewrite loop up to max_retries times.

`RequirementSpec`¶

Field	Type	Default
`name`	`str`	required
`keywords`	`tuple[str, ...]`	required
`description`	`str`	''
`mandatory`	`bool`	True

`StandardDeficiency(BaseModel)`¶

A single deficiency found during verification.

Field	Type	Default
`standard_id`	`str`	required
`standard_name`	`str`	required
`description`	`str`	required
`severity`	`Literal['minor', 'major', 'critical']`	'minor'
`remediation_hint`	`str`	''
`clause_ref`	`str`	''
`clause_text`	`str`	''
`layer_source`	`str`	''

`StandardsVerificationInput(BaseModel)`¶

Input to ProfessionalStandardsBlock.

Field	Type	Default
`job_type`	`str`	required
`job_output`	`dict[str, Any]`	Field(default_factory=dict)
`jurisdiction`	`str`	''
`failure_mode`	`str`	''
`context`	`dict[str, Any]`	Field(default_factory=dict)
`request_id`	`str`	''
`task_id`	`str`	''
`run_id`	`str`	''
`max_retries`	`int`	0
`source_urls`	`list[str]`	Field(default_factory=list)
`rag_documents`	`list[str]`	Field(default_factory=list)
`grounding_domains`	`list[str]`	Field(default_factory=list)
`enable_web_check`	`bool`	False
`enable_grounding`	`bool`	True
`enable_rag`	`bool`	False

`StandardsVerificationOutput(BaseModel)`¶

Output from ProfessionalStandardsBlock.

Field	Type	Default
`job_type`	`str`	required
`jurisdiction`	`str`	required
`passed`	`bool \\| None`	required
`grade`	`QualityGrade`	required
`deficiencies`	`list[StandardDeficiency]`	Field(default_factory=list)
`applicable_standards`	`list[str]`	Field(default_factory=list)
`remediation_hints`	`list[str]`	Field(default_factory=list)
`confidence`	`float`	0.5
`failure_mode_applied`	`str`	'grade'
`auto_remediation_attempts`	`int`	0
`retrieval_sources`	`list[str]`	Field(default_factory=list)
`result`	`str`	''
`human_review_required`	`bool`	False
`human_review_reasons`	`list[str]`	Field(default_factory=list)
`evaluation_layers`	`list[str]`	Field(default_factory=list)
`layer_agreements`	`dict[str, str]`	Field(default_factory=dict)
`degraded`	`bool`	False
`degradation_reason`	`str \\| None`	None
`completion_state`	`CompletionState`	'qualified-draft'
`warning_card`	`dict[str, Any]`	Field(default_factory=dict)
`evidence`	`dict[str, Any]`	Field(default_factory=dict)
`request_id`	`str`	''
`task_id`	`str`	''
`run_id`	`str`	''