Chapter 9: Governance — Constitutions, Tags, and Quality Gates

Governance in FCC is not an afterthought bolted onto the framework. It is woven into every persona, every workflow transition, and every deliverable evaluation. This chapter covers the three pillars of FCC governance: the constitution model, the tag registry, and the quality gate system.

The flowchart below traces an artifact through the three governance stages — schema validation, constitution check, and quality-gate evaluation — and shows the halt, feedback, and approval outcomes at each branch.

flowchart TD
    A[Artifact Produced] --> V{Schema Validation}
    V -->|Fail| HALT1[Reject: Invalid Structure]
    V -->|Pass| C{Constitution Check}
    C -->|Hard-Stop Violation| HALT2[Halt Workflow + Human Escalation]
    C -->|Mandatory Violation| W[Warning + Feedback Edge]
    C -->|Pass| Q{Quality Gate Evaluation}
    Q -->|Below Threshold| FB[Trigger Feedback Loop]
    Q -->|Meets Threshold| OK[Artifact Approved]
    W --> FB
    FB -->|Re-create| A

    style HALT1 fill:#d32f2f,color:#fff
    style HALT2 fill:#d32f2f,color:#fff
    style OK fill:#4CAF50,color:#fff
    style FB fill:#FF9800,color:#fff

This fail-fast then fail-loud ordering keeps cheap checks at the front of the pipeline and reserves human escalation for the cases that truly require it.

The 3-Tier Constitution Model

Every persona in FCC can carry a constitution — a set of rules organized into three tiers of enforcement:

Tier	Name	Enforcement	Example
1	Hard-Stop	Blocking	"Never generate PII in output artifacts"
2	Mandatory	Required	"All blueprints must include data flow diagrams"
3	Preferred	Recommended	"Use active voice in documentation"

Hard-stop rules are non-negotiable. If a deliverable violates a hard-stop rule, the workflow halts and escalates to human review. Mandatory patterns must be followed but can be waived with documented justification. Preferred patterns are best practices that improve consistency but do not block progress.

Constitution rules are defined in each persona's YAML under doc_context.constitution:

doc_context:
  constitution:
    hard_stop:
      - "Never fabricate citations or references"
      - "Never disclose proprietary methodology"
    mandatory:
      - "Include annotated bibliography in all research outputs"
    preferred:
      - "Use APA citation format"

ConstitutionRegistry and PersonaConstitution

The ConstitutionRegistry (in src/fcc/governance/constitution_registry.py) provides a centralized lookup for persona constitutions. It is built from the PersonaRegistry:

from fcc.governance.constitution_registry import ConstitutionRegistry
from fcc.personas.registry import PersonaRegistry
from fcc._resources import get_data_dir

registry = PersonaRegistry.from_yaml_directory(get_data_dir() / "personas")
const_registry = ConstitutionRegistry.from_persona_registry(registry)

# Look up a specific persona's constitution
rc_const = const_registry.get("RC")
print(rc_const.hard_stop_rules)  # tuple of hard-stop rule strings
print(rc_const.total_rules)      # total count across all tiers

Each PersonaConstitution is a frozen dataclass with:

• persona_id and persona_name
• hard_stop_rules — tuple of tier-1 rule strings
• mandatory_patterns — tuple of tier-2 rule strings
• preferred_patterns — tuple of tier-3 rule strings
• to_tier_model() — converts to a ConstitutionTierModel for integration with the governance enforcement engine

The to_tier_model() method generates ConstitutionRule objects with structured IDs (e.g., RC-HS-001 for the first hard-stop rule of the Research Crafter). This enables programmatic enforcement and audit trails.

Tag Registry: 30 Tags with Structured Taxonomy

The tag registry (src/fcc/data/governance/tag_registry.yaml) defines 30 tags that classify persona capabilities along three dimensions:

• capability — the specific skill (e.g., persona-research-crafter)
• category — the functional group (e.g., knowledge-sharing, integration-automation, governance-compliance)
• supercategory — the strategic alignment bucket (e.g., strategy-alignment, operational-excellence)

Tags serve multiple purposes:

1. Discovery — find personas by capability or category.
2. Governance scoping — apply rules to all personas in a category.
3. Cross-reference — the cross-reference matrix uses tags to identify upstream/downstream relationships.
4. Plugin registration — plugins declare which tags they extend.

Example tag structure:

tags:
  - capability: persona-research-crafter
    category: knowledge-sharing
    supercategory: strategy-alignment
  - capability: persona-catalog-indexer-architect
    category: integration-automation
    supercategory: operational-excellence

Quality Gates: 25 Gates Across All Personas

Quality gates (src/fcc/data/governance/quality_gates.yaml) define the minimum quality bar for each persona's deliverables. Each gate specifies:

• id — unique gate identifier (e.g., QG-RC-001)
• name — human-readable name (e.g., "Research Inventory Completeness")
• persona_id — the persona this gate applies to (or ALL)
• threshold — minimum pass score (0.0 to 1.0)
• checks — list of check identifiers that must pass

The 25 gates cover:

• Core personas — research completeness, blueprint quality, documentation standards, runbook readiness, user guide accessibility
• Integration personas — catalog indexing, UI mockup fidelity, taxonomy consistency, traceability coverage
• Governance personas — compliance audit coverage, data governance, privacy taxonomy completeness
• Cross-cutting — R.I.S.C.E.A.R. extended completeness (applies to ALL)

Gates integrate with the collaboration engine's ApprovalGate model (see Chapter 8). When a quality gate is referenced by an ApprovalGate, the ScoringEngine evaluates the deliverable against the gate's checks and threshold.

Compliance Enforcement

FCC enforces compliance at three levels:

Level 1: Schema Validation

JSON schemas in src/fcc/data/schemas/ validate persona YAML, workflow definitions, event payloads, and collaboration sessions. The FCCValidator class runs schema validation as the first line of defense.

Level 2: Constitution Checks

During simulation and collaboration, the ConstitutionRegistry checks deliverables against persona-specific rules. Hard-stop violations halt the workflow; mandatory violations generate warnings that require human acknowledgment.

Level 3: Quality Gate Evaluation

At workflow transitions, quality gates assess whether deliverables meet the required standard. Gates can be configured as blocking (workflow pauses until the gate passes) or advisory (warnings are logged but the workflow continues).

The three levels form a defense-in-depth approach:

Schema Validation → Constitution Checks → Quality Gate Evaluation
      (structure)      (content rules)       (quality bar)

Governance Plugins

The plugin system (see Chapter 6) supports governance plugins — plugins that extend the constitution model, add custom quality gates, or introduce new compliance checks.

A governance plugin implements the GovernancePlugin interface:

class GovernancePlugin:
    plugin_type = "governance"

    def register_rules(self) -> list[ConstitutionRule]:
        """Return additional constitution rules."""
        ...

    def register_gates(self) -> list[dict]:
        """Return additional quality gate definitions."""
        ...

This allows organizations to layer domain-specific governance (e.g., HIPAA compliance for healthcare, SOX controls for finance) on top of FCC's built-in rules without modifying the core framework.

Governance in Practice

A typical governance setup involves:

1. Define constitutions — add hard_stop, mandatory, and preferred rules to each persona's YAML.
2. Configure quality gates — add gates to quality_gates.yaml or via a governance plugin.
3. Wire gates to collaboration — attach ApprovalGate objects to workflow nodes in the collaboration session.
4. Monitor compliance — use the quality dashboard (see Chapter 7 for events) to track gate pass rates and constitution violations.

For a complete walkthrough of governance setup, see Lab 8 in the labs chapter.

Key Takeaways

• FCC uses a 3-tier constitution model: hard-stop (blocking), mandatory (required), preferred (recommended).
• The ConstitutionRegistry provides per-persona constitution lookup from the PersonaRegistry.
• 30 tags classify personas by capability, category, and supercategory.
• 25 quality gates define minimum quality bars across all persona types.
• Compliance enforcement operates at three levels: schema, constitution, and quality gates.
• Governance plugins allow organizations to extend the model without modifying core code.